47#include "llvm/ADT/SmallString.h"
48#include "llvm/ADT/Triple.h"
52#include <unordered_map>
59 Decl *Group[2] = { OwnedType, Ptr };
70 TypeNameValidatorCCC(
bool AllowInvalid,
bool WantClass =
false,
71 bool AllowTemplates =
false,
72 bool AllowNonTemplates =
true)
73 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
74 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
75 WantExpressionKeywords =
false;
76 WantCXXNamedCasts =
false;
77 WantRemainingKeywords =
false;
82 if (!AllowInvalidDecl && ND->isInvalidDecl())
86 return AllowTemplates;
92 if (AllowNonTemplates)
98 auto *RD = dyn_cast<CXXRecordDecl>(ND);
99 if (!RD || !RD->isInjectedClassName())
102 return RD->getDescribedClassTemplate() ||
109 return !WantClassName && candidate.
isKeyword();
112 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
113 return std::make_unique<TypeNameValidatorCCC>(*
this);
117 bool AllowInvalidDecl;
120 bool AllowNonTemplates;
132 case tok::kw___int64:
133 case tok::kw___int128:
135 case tok::kw_unsigned:
143 case tok::kw__Float16:
144 case tok::kw___float128:
145 case tok::kw___ibm128:
146 case tok::kw_wchar_t:
148 case tok::kw___underlying_type:
149 case tok::kw___auto_type:
152 case tok::annot_typename:
153 case tok::kw_char16_t:
154 case tok::kw_char32_t:
156 case tok::annot_decltype:
157 case tok::kw_decltype:
160 case tok::kw_char8_t:
171enum class UnqualifiedTypeNameLookupResult {
182static UnqualifiedTypeNameLookupResult
187 return UnqualifiedTypeNameLookupResult::NotFound;
189 UnqualifiedTypeNameLookupResult FoundTypeDecl =
190 UnqualifiedTypeNameLookupResult::NotFound;
193 if (
auto *BaseTT =
Base.getType()->getAs<
TagType>())
194 BaseRD = BaseTT->getAsCXXRecordDecl();
198 if (!TST || !TST->isDependentType())
200 auto *TD = TST->getTemplateName().getAsTemplateDecl();
203 if (
auto *BasePrimaryTemplate =
204 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
206 BaseRD = BasePrimaryTemplate;
207 else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
209 CTD->findPartialSpecialization(
Base.getType()))
217 if (!isa<TypeDecl>(ND))
218 return UnqualifiedTypeNameLookupResult::FoundNonType;
219 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
221 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
223 case UnqualifiedTypeNameLookupResult::FoundNonType:
224 return UnqualifiedTypeNameLookupResult::FoundNonType;
225 case UnqualifiedTypeNameLookupResult::FoundType:
226 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
228 case UnqualifiedTypeNameLookupResult::NotFound:
235 return FoundTypeDecl;
243 UnqualifiedTypeNameLookupResult FoundTypeDecl =
244 UnqualifiedTypeNameLookupResult::NotFound;
246 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
250 RD = dyn_cast<CXXRecordDecl>(DC);
254 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
260 S.
Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
288 bool isClassName,
bool HasTrailingDot,
290 bool IsCtorOrDtorName,
291 bool WantNontrivialTypeSourceInfo,
292 bool IsClassTemplateDeductionContext,
295 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
297 !isClassName && !HasTrailingDot;
319 if (!isClassName && !IsCtorOrDtorName)
324 if (WantNontrivialTypeSourceInfo)
353 if (ObjectTypePtr &&
Result.empty()) {
377 switch (
Result.getResultKind()) {
381 TypeNameValidatorCCC CCC(
true, isClassName,
382 AllowDeducedTemplate);
387 bool MemberOfUnknownSpecialization;
396 if (Correction && (NNS || NewII != &II) &&
402 Template, MemberOfUnknownSpecialization))) {
404 isClassName, HasTrailingDot, ObjectTypePtr,
406 WantNontrivialTypeSourceInfo,
407 IsClassTemplateDeductionContext);
410 PDiag(diag::err_unknown_type_or_class_name_suggest)
411 <<
Result.getLookupName() << isClassName);
414 *CorrectedII = NewII;
423 Result.suppressDiagnostics();
433 Result.suppressDiagnostics();
439 Res != ResEnd; ++Res) {
441 if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(
448 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Res);
460 Result.suppressDiagnostics();
471 IIDecl =
Result.getFoundDecl();
472 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*
Result.begin());
476 assert(IIDecl &&
"Didn't find decl");
479 if (
TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
483 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
484 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
485 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
486 FoundRD->isInjectedClassName() &&
488 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
499 FoundUsingShadow =
nullptr;
500 }
else if (
auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
504 FoundUsingShadow =
nullptr;
505 }
else if (AllowDeducedTemplate) {
507 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
513 FoundUsingShadow =
nullptr;
519 Result.suppressDiagnostics();
523 if (FoundUsingShadow)
529 if (SS && SS->
isNotEmpty() && !IsCtorOrDtorName &&
530 !isa<ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(IIDecl)) {
531 if (WantNontrivialTypeSourceInfo) {
554 auto *ND = dyn_cast<NamespaceDecl>(DC);
555 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
557 else if (
auto *RD = dyn_cast<CXXRecordDecl>(DC))
559 RD->getTypeForDecl());
560 else if (isa<TranslationUnitDecl>(DC))
563 llvm_unreachable(
"something isn't in TU scope?");
574 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
575 if (MD->getParent()->hasAnyDependentBases())
583 bool IsTemplateTypeArg) {
584 assert(
getLangOpts().MSVCCompat &&
"shouldn't be called in non-MSVC mode");
587 if (IsTemplateTypeArg &&
getCurScope()->isTemplateParamScope()) {
596 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
602 RD->getTypeForDecl());
606 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
641 switch (TD->getTagKind()) {
678 return S->isFunctionPrototypeScope();
688 bool IsTemplateName) {
693 SuggestedType =
nullptr;
697 TypeNameValidatorCCC CCC(
false,
false,
704 bool CanRecover = !IsTemplateName;
705 if (Corrected.isKeyword()) {
708 PDiag(IsTemplateName ? diag::err_no_template_suggest
709 : diag::err_unknown_typename_suggest)
711 II = Corrected.getCorrectionAsIdentifierInfo();
714 if (!SS || !SS->
isSet()) {
716 PDiag(IsTemplateName ? diag::err_no_template_suggest
717 : diag::err_unknown_typename_suggest)
720 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
721 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
722 II->
getName().equals(CorrectedStr);
725 ? diag::err_no_member_template_suggest
726 : diag::err_unknown_nested_typename_suggest)
727 << II << DC << DroppedSpecifier << SS->
getRange(),
730 llvm_unreachable(
"could not have corrected a typo here");
737 if (Corrected.getCorrectionSpecifier())
742 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
743 tmpSS.
isSet() ? &tmpSS : SS,
false,
false,
nullptr,
753 Name.setIdentifier(II, IILoc);
756 bool MemberOfUnknownSpecialization;
758 Name,
nullptr,
true, TemplateResult,
769 Diag(IILoc, IsTemplateName ? diag::err_no_template
770 : diag::err_unknown_typename)
773 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
774 : diag::err_typename_nested_not_found)
780 unsigned DiagID = diag::err_typename_missing;
782 DiagID = diag::ext_typename_missing;
789 *SS, *II, IILoc).
get();
792 "Invalid scope specifier has already been diagnosed");
800 NextToken.
is(tok::less);
803 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
806 if (CheckTemplate && isa<TemplateDecl>(*I))
820 StringRef FixItTagName;
821 switch (Tag->getTagKind()) {
823 FixItTagName =
"class ";
827 FixItTagName =
"enum ";
831 FixItTagName =
"struct ";
835 FixItTagName =
"__interface ";
839 FixItTagName =
"union ";
843 StringRef TagName = FixItTagName.drop_back();
844 SemaRef.
Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
845 << Name << TagName << SemaRef.
getLangOpts().CPlusPlus
850 SemaRef.
Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
865 const Token &NextToken,
870 assert(NextToken.
isNot(tok::coloncolon) &&
871 "parse nested name specifiers before calling ClassifyName");
911 bool SecondTry =
false;
912 bool IsFilteredTemplateName =
false;
915 switch (
Result.getResultKind()) {
919 if (SS.
isEmpty() && NextToken.
is(tok::l_paren)) {
965 if (!SecondTry && CCC) {
970 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
971 unsigned QualifiedDiag = diag::err_no_member_suggest;
974 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
976 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
977 UnqualifiedDiag = diag::err_no_template_suggest;
978 QualifiedDiag = diag::err_no_member_template_suggest;
979 }
else if (UnderlyingFirstDecl &&
980 (isa<TypeDecl>(UnderlyingFirstDecl) ||
981 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
982 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
983 UnqualifiedDiag = diag::err_unknown_typename_suggest;
984 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
990 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
991 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
992 Name->getName().equals(CorrectedStr);
995 << DroppedSpecifier << SS.
getRange());
999 Name = Corrected.getCorrectionAsIdentifierInfo();
1002 if (Corrected.isKeyword())
1008 Result.setLookupName(Corrected.getCorrection());
1030 Result.suppressDiagnostics();
1072 if (!
Result.isAmbiguous()) {
1073 IsFilteredTemplateName =
true;
1083 (IsFilteredTemplateName ||
1099 if (!IsFilteredTemplateName)
1102 bool IsFunctionTemplate;
1106 IsFunctionTemplate =
true;
1109 }
else if (!
Result.empty()) {
1117 dyn_cast<UsingShadowDecl>(*
Result.begin());
1118 assert(!FoundUsingShadow ||
1119 TD == cast<TemplateDecl>(FoundUsingShadow->
getTargetDecl()));
1129 IsFunctionTemplate =
true;
1133 if (IsFunctionTemplate) {
1137 Result.suppressDiagnostics();
1148 if (
const auto *USD = dyn_cast<UsingShadowDecl>(Found))
1174 dyn_cast<ObjCCompatibleAliasDecl>(
FirstDecl))
1175 Class = Alias->getClassInterface();
1181 if (NextToken.
is(tok::period)) {
1184 Result.suppressDiagnostics();
1196 if (
auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
FirstDecl)) {
1209 bool NextIsOp = NextToken.
isOneOf(tok::amp, tok::star);
1210 if ((NextToken.
is(tok::identifier) ||
1212 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1224 if (
Result.isSingleResult() && !ADL && !
FirstDecl->isCXXClassMember())
1228 Result.suppressDiagnostics();
1231 Result.getLookupNameInfo(), ADL,
Result.isOverloadedResult(),
1248 bool IsAddressOfOperand) {
1251 NameInfo, IsAddressOfOperand,
1258 const Token &NextToken) {
1276 if ((*ULE->decls_begin())->isCXXClassMember()) {
1278 SS.
Adopt(ULE->getQualifierLoc());
1283 Result.setNamingClass(ULE->getNamingClass());
1284 for (
auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I)
1285 Result.addDecl(*I, I.getAccess());
1298 auto *TD = Name.getAsTemplateDecl();
1301 if (isa<ClassTemplateDecl>(TD))
1303 if (isa<FunctionTemplateDecl>(TD))
1305 if (isa<VarTemplateDecl>(TD))
1307 if (isa<TypeAliasTemplateDecl>(TD))
1309 if (isa<TemplateTemplateParmDecl>(TD))
1311 if (isa<ConceptDecl>(TD))
1318 "The next DeclContext should be lexically contained in the current one.");
1324 assert(
CurContext &&
"DeclContext imbalance!");
1327 assert(
CurContext &&
"Popped translation unit!");
1337 assert(
CurContext &&
"skipping definition of undefined tag");
1368 assert(!S->getEntity() &&
"scope already has entity");
1371 Scope *Ancestor = S->getParent();
1379 if (S->getParent()->isTemplateParamScope()) {
1387 assert(S->getEntity() ==
CurContext &&
"Context imbalance!");
1391 Scope *Ancestor = S->getParent();
1400 assert(S->isTemplateParamScope() &&
1401 "expected to be initializing a template parameter scope");
1425 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1429 cast<Decl>(DC)->getDescribedTemplateParams()) {
1430 unsigned DCDepth = TPL->getDepth() + 1;
1431 if (DCDepth > ScopeDepth)
1433 if (ScopeDepth == DCDepth)
1438 S->setLookupEntity(SearchDCAfterScope);
1452 "The next DeclContext should be lexically contained in the current one.");
1456 for (
unsigned P = 0, NumParams = FD->
getNumParams();
P < NumParams; ++
P) {
1459 if (Param->getIdentifier()) {
1469 assert(
CurContext &&
"DeclContext imbalance!");
1471 assert(
CurContext &&
"Popped translation unit!");
1500 return ND->
hasAttr<OverloadableAttr>();
1503 return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
1513 while (S->getEntity() && S->getEntity()->isTransparentContext())
1528 if (isa<FunctionDecl>(D) &&
1529 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1535 for (; I != IEnd; ++I) {
1547 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1554 if (!S->isDeclScope(*I))
1568 bool AllowInlineNamespace) {
1576 if (ScopeDC->getPrimaryContext() == TargetDC)
1578 }
while ((S = S->getParent()));
1590 bool ConsiderLinkage,
1591 bool AllowInlineNamespace) {
1644 if (NewIsModuleInterface || OldIsModuleInterface) {
1650 << NewIsModuleInterface
1652 << OldIsModuleInterface
1683 if (!IsNewExported && !IsOldExported)
1689 assert(IsNewExported);
1697 Diag(New->
getLocation(), diag::err_redeclaration_non_exported) << New << S;
1733 "New and Old are not the same definition, we should diagnostic it "
1734 "immediately instead of checking it.");
1737 "We shouldn't see unreachable definitions here.");
1785 return OldM == NewM;
1818 return CD->isCopyConstructor();
1837 if (
const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1838 if (!RD->hasNameForLinkage())
1867 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1873 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1876 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1881 if (FD->isInlined() && !
isMainFileLoc(*
this, FD->getLocation()))
1885 if (FD->doesThisDeclarationHaveABody() &&
1888 }
else if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1898 if (VD->isStaticDataMember() &&
1901 if (VD->isStaticDataMember() &&
1903 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1906 if (VD->isInline() && !
isMainFileLoc(*
this, VD->getLocation()))
1915 return mightHaveNonExternalLinkage(D);
1922 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1928 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1942 if (
auto *DD = dyn_cast<DecompositionDecl>(D)) {
1946 for (
auto *BD : DD->bindings())
1947 if (BD->isReferenced())
1955 if (D->
hasAttr<UnusedAttr>() || D->
hasAttr<ObjCPreciseLifetimeAttr>())
1958 if (isa<LabelDecl>(D))
1964 if (
const auto *R = dyn_cast<CXXRecordDecl>(D->
getDeclContext()))
1967 WithinFunction || (R->isLocalClass() && !R->isDependentType());
1968 if (!WithinFunction)
1971 if (isa<TypedefNameDecl>(D))
1975 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
1979 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1981 const Expr *Init = VD->getInit();
1982 if (
const auto *Cleanups = dyn_cast_or_null<ExprWithCleanups>(Init))
1983 Init = Cleanups->getSubExpr();
1985 const auto *Ty = VD->getType().getTypePtr();
1990 if (TT->getDecl()->hasAttr<UnusedAttr>())
1996 if (
const auto *MTE = dyn_cast_or_null<MaterializeTemporaryExpr>(Init)) {
1997 if (MTE->getExtendingDecl()) {
1998 Ty = VD->getType().getNonReferenceType().getTypePtr();
1999 Init = MTE->getSubExpr()->IgnoreImplicitAsWritten();
2005 if (Ty->isIncompleteType() || Ty->isDependentType())
2010 Ty = Ty->getBaseElementTypeUnsafe();
2013 const TagDecl *Tag = TT->getDecl();
2014 if (Tag->hasAttr<UnusedAttr>())
2017 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2018 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
2023 dyn_cast<CXXConstructExpr>(Init);
2026 if (!CD->
isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
2027 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
2033 if (Init->isTypeDependent()) {
2035 if (!Ctor->isTrivial())
2041 if (isa<CXXUnresolvedConstructExpr>(Init))
2055 if (isa<LabelDecl>(D)) {
2070 for (
auto *TmpD : D->
decls()) {
2071 if (
const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
2073 else if(
const auto *R = dyn_cast<RecordDecl>(TmpD))
2084 if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2095 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
2096 DiagID = diag::warn_unused_exception_param;
2097 else if (isa<LabelDecl>(D))
2098 DiagID = diag::warn_unused_label;
2100 DiagID = diag::warn_unused_variable;
2114 if (Ty->isReferenceType() || Ty->isDependentType())
2118 const TagDecl *Tag = TT->getDecl();
2119 if (Tag->hasAttr<UnusedAttr>())
2123 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2124 if (!RD->hasAttr<WarnUnusedAttr>())
2132 if (VD->
hasAttr<BlocksAttr>() && Ty->isObjCObjectPointerType())
2138 if (VD->
hasAttr<ObjCPreciseLifetimeAttr>() && Ty->isObjCObjectPointerType())
2145 assert(iter->getSecond() >= 0 &&
2146 "Found a negative number of references to a VarDecl");
2147 if (iter->getSecond() != 0)
2149 unsigned DiagID =
isa<ParmVarDecl>(VD) ? diag::warn_unused_but_set_parameter
2150 : diag::warn_unused_but_set_variable;
2159 bool Diagnose =
false;
2163 Diagnose = L->
getStmt() ==
nullptr;
2171 if (S->decl_empty())
return;
2173 "Scope shouldn't contain decls!");
2175 for (
auto *TmpD : S->decls()) {
2176 assert(TmpD &&
"This decl didn't get pushed??");
2178 assert(isa<NamedDecl>(TmpD) &&
"Decl isn't NamedDecl?");
2182 if (!S->hasUnrecoverableErrorOccurred()) {
2184 if (
const auto *RD = dyn_cast<RecordDecl>(D))
2186 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2195 if (
LabelDecl *LD = dyn_cast<LabelDecl>(D))
2201 auto ShadowI = ShadowingDecls.find(D);
2202 if (ShadowI != ShadowingDecls.end()) {
2203 if (
const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2205 << D << FD << FD->getParent();
2206 Diag(FD->getLocation(), diag::note_previous_declaration);
2208 ShadowingDecls.erase(ShadowI);
2228 bool DoTypoCorrection) {
2233 if (!IDecl && DoTypoCorrection) {
2277 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2295 return "ucontext.h";
2297 llvm_unreachable(
"unhandled error kind");
2308 Parent->addDecl(CLinkageDecl);
2323 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2326 FT->getParamType(i),
nullptr,
SC_None,
nullptr);
2328 Params.push_back(parm);
2330 New->setParams(Params);
2342 Scope *S,
bool ForRedeclaration,
2349 if (!ForRedeclaration)
2361 Diag(Loc, diag::warn_implicit_decl_no_jmp_buf)
2368 Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
2374 if (!ForRedeclaration &&
2377 Diag(Loc,
LangOpts.C99 ? diag::ext_implicit_lib_function_decl_c99
2378 : diag::ext_implicit_lib_function_decl)
2381 Diag(Loc, diag::note_include_header_or_declare)
2418 while (Filter.hasNext()) {
2427 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2429 Decl->getUnderlyingType()))
2434 if (OldTD->getAnonDeclWithTypedefName(
true) &&
2435 Decl->getAnonDeclWithTypedefName())
2448 OldType = OldTypedef->getUnderlyingType();
2456 Diag(New->
getLocation(), diag::err_redefinition_variably_modified_typedef)
2464 if (OldType != NewType &&
2470 << Kind << NewType << OldType;
2494 switch (TypeID->getLength()) {
2498 if (!TypeID->isStr(
"id"))
2501 if (!T->isPointerType())
2503 if (!T->isVoidPointerType()) {
2514 if (!TypeID->isStr(
"Class"))
2521 if (!TypeID->isStr(
"SEL"))
2548 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2549 auto *OldTag = OldTD->getAnonDeclWithTypedefName(
true);
2552 if (OldTag && NewTag &&
2553 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2558 if (OldTD->isModed())
2560 OldTD->getUnderlyingType());
2569 if (isa<EnumDecl>(NewTag)) {
2571 for (
auto *D : NewTag->decls()) {
2576 ED->getLexicalDeclContext()->removeDecl(ED);
2626 if (!isa<TypedefNameDecl>(Old))
2658 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2659 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2660 for (
const auto *i : D->
attrs())
2661 if (i->getKind() == A->
getKind()) {
2663 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2668 if (OA && isa<OwnershipAttr>(i))
2677 if (
VarDecl *VD = dyn_cast<VarDecl>(D))
2678 return VD->isThisDeclarationADefinition();
2679 if (
TagDecl *TD = dyn_cast<TagDecl>(D))
2680 return TD->isCompleteDefinition() || TD->isBeingDefined();
2691 AlignedAttr *OldAlignasAttr =
nullptr;
2692 AlignedAttr *OldStrictestAlignAttr =
nullptr;
2693 unsigned OldAlign = 0;
2701 if (I->isAlignmentDependent())
2707 unsigned Align = I->getAlignment(S.
Context);
2708 if (Align > OldAlign) {
2710 OldStrictestAlignAttr = I;
2715 AlignedAttr *NewAlignasAttr =
nullptr;
2716 unsigned NewAlign = 0;
2718 if (I->isAlignmentDependent())
2724 unsigned Align = I->getAlignment(S.
Context);
2725 if (Align > NewAlign)
2729 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2737 if (OldAlign == 0 || NewAlign == 0) {
2739 if (
ValueDecl *VD = dyn_cast<ValueDecl>(New))
2750 if (OldAlign != NewAlign) {
2751 S.
Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2754 S.
Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2769 S.
Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2773 bool AnyAdded =
false;
2776 if (OldAlign > NewAlign) {
2777 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.
Context);
2778 Clone->setInherited(
true);
2784 if (OldAlignasAttr && !NewAlignasAttr &&
2785 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2786 AlignedAttr *Clone = OldAlignasAttr->clone(S.
Context);
2787 Clone->setInherited(
true);
2795#define WANT_DECL_MERGE_LOGIC
2796#include "clang/Sema/AttrParsedAttrImpl.inc"
2797#undef WANT_DECL_MERGE_LOGIC
2804 if (!DiagnoseMutualExclusions(S, D,
Attr))
2815 if (
const auto *AA = dyn_cast<AvailabilityAttr>(
Attr))
2817 D, *AA, AA->getPlatform(), AA->
isImplicit(), AA->getIntroduced(),
2818 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2819 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2821 else if (
const auto *VA = dyn_cast<VisibilityAttr>(
Attr))
2823 else if (
const auto *VA = dyn_cast<TypeVisibilityAttr>(
Attr))
2825 else if (
const auto *ImportA = dyn_cast<DLLImportAttr>(
Attr))
2827 else if (
const auto *ExportA = dyn_cast<DLLExportAttr>(
Attr))
2829 else if (
const auto *EA = dyn_cast<ErrorAttr>(
Attr))
2831 else if (
const auto *FA = dyn_cast<FormatAttr>(
Attr))
2832 NewAttr = S.
mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(),
2834 else if (
const auto *SA = dyn_cast<SectionAttr>(
Attr))
2836 else if (
const auto *CSA = dyn_cast<CodeSegAttr>(
Attr))
2838 else if (
const auto *IA = dyn_cast<MSInheritanceAttr>(
Attr))
2840 IA->getInheritanceModel());
2841 else if (
const auto *AA = dyn_cast<AlwaysInlineAttr>(
Attr))
2844 else if (S.
getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2845 (isa<CUDAHostAttr>(
Attr) || isa<CUDADeviceAttr>(
Attr) ||
2846 isa<CUDAGlobalAttr>(
Attr))) {
2850 }
else if (
const auto *MA = dyn_cast<MinSizeAttr>(
Attr))
2852 else if (
const auto *SNA = dyn_cast<SwiftNameAttr>(
Attr))
2854 else if (
const auto *OA = dyn_cast<OptimizeNoneAttr>(
Attr))
2856 else if (
const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(
Attr))
2858 else if (isa<AlignedAttr>(
Attr))
2862 else if ((isa<DeprecatedAttr>(
Attr) || isa<UnavailableAttr>(
Attr)) &&
2867 else if (
const auto *UA = dyn_cast<UuidAttr>(
Attr))
2868 NewAttr = S.
mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
2869 else if (
const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(
Attr))
2871 else if (
const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(
Attr))
2873 else if (
const auto *TCBA = dyn_cast<EnforceTCBAttr>(
Attr))
2875 else if (
const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(
Attr))
2877 else if (
const auto *BTFA = dyn_cast<BTFDeclTagAttr>(
Attr))
2879 else if (
const auto *NT = dyn_cast<HLSLNumThreadsAttr>(
Attr))
2882 else if (
const auto *SA = dyn_cast<HLSLShaderAttr>(
Attr))
2890 if (isa<MSInheritanceAttr>(NewAttr))
2899 if (
const TagDecl *TD = dyn_cast<TagDecl>(D))
2900 return TD->getDefinition();
2901 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2907 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2909 if (FD->isDefined(Def,
true))
2916 for (
const auto *Attribute : D->
attrs())
2917 if (Attribute->getKind() == Kind)
2929 if (!Def || Def == New)
2933 for (
unsigned I = 0, E = NewAttributes.size(); I != E;) {
2934 const Attr *NewAttribute = NewAttributes[I];
2936 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
2943 NewAttributes.erase(NewAttributes.begin() + I);
2951 ? diag::err_alias_after_tentative
2952 : diag::err_redefinition;
2954 if (
Diag == diag::err_redefinition)
2964 if (
const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2977 if (isa<C11NoReturnAttr>(NewAttribute)) {
2981 }
else if (isa<UuidAttr>(NewAttribute)) {
2985 }
else if (
const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2986 if (AA->isAlignas()) {
2997 S.
Diag(NewAttribute->
getLocation(), diag::note_alignas_on_declaration)
2999 NewAttributes.erase(NewAttributes.begin() + I);
3003 }
else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
3009 diag::err_loader_uninitialized_redeclaration);
3011 NewAttributes.erase(NewAttributes.begin() + I);
3015 }
else if (isa<SelectAnyAttr>(NewAttribute) &&
3016 cast<VarDecl>(New)->isInline() &&
3017 !cast<VarDecl>(New)->isInlineSpecified()) {
3024 }
else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
3032 diag::warn_attribute_precede_definition);
3034 NewAttributes.erase(NewAttributes.begin() + I);
3040 const ConstInitAttr *CIAttr,
3041 bool AttrBeforeInit) {
3048 std::string SuitableSpelling;
3050 SuitableSpelling = std::string(
3052 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3054 InsertLoc, {tok::l_square, tok::l_square,
3055 S.PP.getIdentifierInfo(
"clang"), tok::coloncolon,
3056 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3057 tok::r_square, tok::r_square}));
3058 if (SuitableSpelling.empty())
3060 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
3061 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3062 tok::r_paren, tok::r_paren}));
3063 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus20)
3064 SuitableSpelling =
"constinit";
3065 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3066 SuitableSpelling =
"[[clang::require_constant_initialization]]";
3067 if (SuitableSpelling.empty())
3068 SuitableSpelling =
"__attribute__((require_constant_initialization))";
3069 SuitableSpelling +=
" ";
3071 if (AttrBeforeInit) {
3074 assert(CIAttr->isConstinit() &&
"should not diagnose this for attribute");
3077 S.
Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
3081 S.
Diag(CIAttr->getLocation(),
3082 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
3083 : diag::warn_require_const_init_added_too_late)
3086 << CIAttr->isConstinit()
3095 UsedAttr *NewAttr = OldAttr->clone(
Context);
3096 NewAttr->setInherited(
true);
3100 RetainAttr *NewAttr = OldAttr->clone(
Context);
3101 NewAttr->setInherited(
true);
3111 const auto *OldConstInit = Old->
getAttr<ConstInitAttr>();
3112 const auto *NewConstInit = New->
getAttr<ConstInitAttr>();
3113 if (
bool(OldConstInit) !=
bool(NewConstInit)) {
3121 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
3124 if (InitDecl == NewVD) {
3128 if (OldConstInit && OldConstInit->isConstinit())
3131 }
else if (NewConstInit) {
3135 if (InitDecl && InitDecl != NewVD) {
3138 NewVD->dropAttr<ConstInitAttr>();
3146 if (AsmLabelAttr *NewA = New->
getAttr<AsmLabelAttr>()) {
3147 if (AsmLabelAttr *OldA = Old->
getAttr<AsmLabelAttr>()) {
3148 if (!OldA->isEquivalent(NewA)) {
3151 Diag(OldA->getLocation(), diag::note_previous_declaration);
3153 }
else if (Old->
isUsed()) {
3162 if (
const auto *NewAbiTagAttr = New->
getAttr<AbiTagAttr>()) {
3163 if (
const auto *OldAbiTagAttr = Old->
getAttr<AbiTagAttr>()) {
3164 for (
const auto &NewTag : NewAbiTagAttr->tags()) {
3165 if (!llvm::is_contained(OldAbiTagAttr->tags(), NewTag)) {
3166 Diag(NewAbiTagAttr->getLocation(),
3167 diag::err_new_abi_tag_on_redeclaration)
3169 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
3173 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
3179 if (New->
hasAttr<SectionAttr>() && !Old->
hasAttr<SectionAttr>()) {
3180 if (
auto *VD = dyn_cast<VarDecl>(New)) {
3182 Diag(New->
getLocation(), diag::warn_attribute_section_on_redeclaration);
3189 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
3190 if (NewCSA && !Old->
hasAttr<CodeSegAttr>() &&
3191 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
3209 if (isa<DeprecatedAttr>(I) ||
3210 isa<UnavailableAttr>(I) ||
3211 isa<AvailabilityAttr>(I)) {
3226 if (isa<UsedAttr>(I) || isa<RetainAttr>(I))
3248 const CarriesDependencyAttr *CDA = newDecl->
getAttr<CarriesDependencyAttr>();
3249 if (CDA && !oldDecl->
hasAttr<CarriesDependencyAttr>()) {
3250 S.
Diag(CDA->getLocation(),
3251 diag::err_carries_dependency_missing_on_first_decl) << 1;
3259 diag::note_carries_dependency_missing_first_decl) << 1;
3265 bool foundAny = newDecl->
hasAttrs();
3287 auto NoSizeInfo = [&Ctx](
QualType Ty) {
3288 if (Ty->isIncompleteArrayType() || Ty->isPointerType())
3296 if (NoSizeInfo(Old) && NoSizeInfo(New))
3328 if (*Oldnullability != *Newnullability) {
3329 S.
Diag(NewParam->
getLocation(), diag::warn_mismatched_nullability_attr)
3348 const auto *OldParamDT = dyn_cast<DecayedType>(OldParam->
getType());
3349 const auto *NewParamDT = dyn_cast<DecayedType>(NewParam->
getType());
3350 if (OldParamDT && NewParamDT &&
3351 OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {
3352 QualType OldParamOT = OldParamDT->getOriginalType();
3353 QualType NewParamOT = NewParamDT->getOriginalType();
3356 << NewParam << NewParamOT;
3367struct GNUCompatibleParamWarning {
3377template <
typename T>
3378static std::pair<diag::kind, SourceLocation>
3382 if (Old->isThisDeclarationADefinition())
3383 PrevDiag = diag::note_previous_definition;
3384 else if (Old->isImplicit()) {
3385 PrevDiag = diag::note_previous_implicit_declaration;
3386 if (
const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3387 if (FD->getBuiltinID())
3388 PrevDiag = diag::note_previous_builtin_declaration;
3391 OldLocation = New->getLocation();
3393 PrevDiag = diag::note_previous_declaration;
3394 return std::make_pair(PrevDiag, OldLocation);
3402 return ((FD->
hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3403 !LangOpts.CPlusPlus &&
3415template <
typename T>
3429template<
typename T>
static bool isExternC(T *D) {
return D->isExternC(); }
3436template<
typename ExpectedDecl>
3458 !Old->getDeclContext()->getRedeclContext()->Equals(
3459 New->getDeclContext()->getRedeclContext()) &&
3464 S.
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3477 const auto *AttrA = A->
getAttr<PassObjectSizeAttr>();
3478 const auto *AttrB = B->
getAttr<PassObjectSizeAttr>();
3481 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3482 AttrA->isDynamic() == AttrB->isDynamic();
3508 if (NamedDC->Equals(SemaDC))
3511 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3513 "unexpected context for redeclaration");
3524 if (
auto *FD = dyn_cast<FunctionDecl>(NewD))
3525 FixSemaDC(FD->getDescribedFunctionTemplate());
3526 else if (
auto *VD = dyn_cast<VarDecl>(NewD))
3527 FixSemaDC(VD->getDescribedVarTemplate());
3542 bool MergeTypeWithOld,
bool NewDeclIsDefn) {
3549 Diag(Shadow->getTargetDecl()->getLocation(),
3550 diag::note_using_decl_target);
3551 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
3596 std::tie(PrevDiag, OldLocation) =
3603 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3610 Diag(OldLocation, PrevDiag);
3613 Diag(OldLocation, PrevDiag);
3618 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
3619 if (!Old->
hasAttr<InternalLinkageAttr>()) {
3623 New->
dropAttr<InternalLinkageAttr>();
3626 if (
auto *EA = New->
getAttr<ErrorAttr>()) {
3627 if (!Old->
hasAttr<ErrorAttr>()) {
3628 Diag(EA->getLocation(), diag::err_attribute_missing_on_first_decl) << EA;
3638 bool OldOvl = Old->
hasAttr<OverloadableAttr>();
3649 const Decl *DiagOld = Old;
3651 auto OldIter = llvm::find_if(Old->
redecls(), [](
const Decl *D) {
3652 const auto *A = D->getAttr<OverloadableAttr>();
3653 return A && !A->isImplicit();
3657 DiagOld = OldIter == Old->
redecls_end() ? nullptr : *OldIter;
3662 diag::note_attribute_overloadable_prev_overload)
3691 bool RequiresAdjustment =
false;
3693 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC()) {
3699 if (!NewCCExplicit) {
3703 RequiresAdjustment =
true;
3715 RequiresAdjustment =
true;
3722 << (!FirstCCExplicit ?
"" :
3726 Diag(
First->getLocation(), diag::note_previous_declaration);
3734 RequiresAdjustment =
true;
3744 Diag(OldLocation, diag::note_previous_declaration);
3749 RequiresAdjustment =
true;
3756 <<
"'ns_returns_retained'";
3757 Diag(OldLocation, diag::note_previous_declaration);
3762 RequiresAdjustment =
true;
3768 AnyX86NoCallerSavedRegistersAttr *
Attr =
3769 New->
getAttr<AnyX86NoCallerSavedRegistersAttr>();
3771 Diag(OldLocation, diag::note_previous_declaration);
3776 RequiresAdjustment =
true;
3779 if (RequiresAdjustment) {
3789 !New->
hasAttr<GNUInlineAttr>() &&
3798 if (New->
hasAttr<GNUInlineAttr>() &&
3809 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3838 OldDeclaredReturnType)) {
3846 Diag(New->
getLocation(), diag::err_member_def_does_not_match_ret_type)
3851 Diag(OldLocation, PrevDiag) << Old << Old->
getType()
3861 if (OldReturnType != NewReturnType) {
3877 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3879 if (OldMethod && NewMethod) {
3886 bool IsClassScopeExplicitSpecialization =
3892 !IsClassScopeExplicitSpecialization) {
3898 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3908 if (isa<CXXConstructorDecl>(OldMethod))
3909 NewDiag = diag::err_constructor_redeclared;
3910 else if (isa<CXXDestructorDecl>(NewMethod))
3911 NewDiag = diag::err_destructor_redeclared;
3912 else if (isa<CXXConversionDecl>(NewMethod))
3913 NewDiag = diag::err_conv_function_redeclared;
3915 NewDiag = diag::err_member_redeclared;
3919 Diag(New->
getLocation(), diag::err_member_redeclared_in_instantiation)
3922 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3935 diag::err_definition_of_implicitly_declared_member)
3941 diag::err_definition_of_explicitly_defaulted_member)
3951 if (
const auto *NRA = New->
getAttr<CXX11NoReturnAttr>())
3952 if (!Old->
hasAttr<CXX11NoReturnAttr>()) {
3953 Diag(NRA->getLocation(), diag::err_attribute_missing_on_first_decl)
3962 const CarriesDependencyAttr *CDA = New->
getAttr<CarriesDependencyAttr>();
3963 if (CDA && !Old->
hasAttr<CarriesDependencyAttr>()) {
3964 Diag(CDA->getLocation(),
3965 diag::err_carries_dependency_missing_on_first_decl) << 0;
3967 diag::note_carries_dependency_missing_first_decl) << 0;
3976 QualType OldQTypeForComparison = OldQType;
3981 OldQTypeForComparison =
QualType(OldTypeForComparison, 0);
3996 Diag(OldLocation, PrevDiag);
3998 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
3999 Diag(OldLocation, PrevDiag);
4070 bool IsWithoutProtoADef =
false, IsWithProtoADef =
false;
4071 if (WithoutProto == New)
4072 IsWithoutProtoADef = NewDeclIsDefn;
4074 IsWithProtoADef = NewDeclIsDefn;
4076 diag::warn_non_prototype_changes_behavior)
4077 << IsWithoutProtoADef << (WithoutProto->
getNumParams() ? 0 : 1)
4078 << (WithoutProto == Old) << IsWithProtoADef;
4088 !IsWithoutProtoADef)
4098 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
4099 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
4102 assert(!OldProto->hasExceptionSpec() &&
"Exception spec in C");
4106 OldProto->getExtProtoInfo());
4112 for (
const auto &ParamType : OldProto->param_types()) {
4115 ParamType,
nullptr,
SC_None,
nullptr);
4116 Param->setScopeInfo(0, Params.size());
4117 Param->setImplicit();
4118 Params.push_back(Param);
4121 New->setParams(Params);
4157 NewProto->getReturnType());
4158 bool LooseCompatible = !MergedReturn.
isNull();
4160 LooseCompatible && Idx != End; ++Idx) {
4164 NewProto->getParamType(Idx))) {
4165 ArgTypes.push_back(NewParm->
getType());
4169 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
4170 NewProto->getParamType(Idx) };
4171 Warnings.push_back(Warn);
4172 ArgTypes.push_back(NewParm->
getType());
4174 LooseCompatible =
false;
4177 if (LooseCompatible) {
4178 for (
unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
4179 Diag(Warnings[Warn].NewParm->getLocation(),
4180 diag::ext_param_promoted_not_compatible_with_prototype)
4181 << Warnings[Warn].PromotedType
4182 << Warnings[Warn].OldParm->getType();
4183 if (Warnings[Warn].OldParm->getLocation().isValid())
4184 Diag(Warnings[Warn].OldParm->getLocation(),
4185 diag::note_previous_declaration);
4188 if (MergeTypeWithOld)
4208 Diag(OldLocation, diag::note_previous_builtin_declaration)
4213 PrevDiag = diag::note_previous_builtin_declaration;
4217 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4231 Scope *S,
bool MergeTypeWithOld) {
4246 for (
unsigned i = 0, e = New->
getNumParams(); i != e; ++i) {
4260 if (!Merged.isNull() && MergeTypeWithOld)
4283 ni != ne && oi != oe; ++ni, ++oi)
4293 ? diag::err_redefinition_different_type
4294 : diag::err_redeclaration_different_type)
4299 std::tie(PrevDiag, OldLocation)
4301 S.
Diag(OldLocation, PrevDiag);
4313 bool MergeTypeWithOld) {
4341 QualType PrevVDTy = PrevVD->getType();
4395 if (MergeTypeWithOld)
4441 if (!shouldLinkPossiblyHiddenDecl(
Previous, New))
4451 OldTemplate = dyn_cast<VarTemplateDecl>(
Previous.getFoundDecl());
4455 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4459 Old = dyn_cast<VarDecl>(
Previous.getFoundDecl());
4462 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4500 if (New->
hasAttr<WeakImportAttr>() &&
4502 !Old->
hasAttr<WeakImportAttr>()) {
4509 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
4510 if (!Old->
hasAttr<InternalLinkageAttr>()) {
4514 New->
dropAttr<InternalLinkageAttr>();
4519 if (MostRecent != Old) {
4532 std::tie(PrevDiag, OldLocation) =
4542 Diag(OldLocation, PrevDiag);
4546 Diag(OldLocation, PrevDiag);
4565 Diag(OldLocation, PrevDiag);
4573 Diag(OldLocation, PrevDiag);
4579 Diag(OldLocation, PrevDiag);
4595 Diag(OldLocation, PrevDiag);
4605 Diag(Def->getLocation(), diag::note_previous_definition);
4619 Diag(OldLocation, PrevDiag);
4622 Diag(OldLocation, PrevDiag);
4630 Diag(OldLocation, PrevDiag);
4640 diag::warn_deprecated_redundant_constexpr_static_def);
4649 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4650 Diag(OldLocation, PrevDiag);
4680 StringRef HdrFilename =
4683 auto noteFromModuleOrInclude = [&](
Module *Mod,
4689 if (IncLoc.isValid()) {
4691 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4697 Diag(IncLoc, diag::note_redefinition_include_same_file)
4698 << HdrFilename.str();
4708 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4716 if (FOld && !HSI.isFileMultipleIncludeGuarded(FOld))
4772 ? S->getMSCurManglingNumber()
4773 : S->getMSLastManglingNumber();
4780 if (isa<CXXRecordDecl>(Tag->getParent())) {
4783 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
4795 Decl *ManglingContextDecl;
4796 std::tie(MCtx, ManglingContextDecl) =
4806struct NonCLikeKind {
4818 explicit operator bool() {
return Kind !=
None; }
4826 return {NonCLikeKind::Invalid, {}};
4833 return {NonCLikeKind::BaseClass,
4845 if (
auto *FD = dyn_cast<FieldDecl>(D)) {
4846 if (FD->hasInClassInitializer()) {
4847 auto *Init = FD->getInClassInitializer();
4848 return {NonCLikeKind::DefaultMemberInit,
4856 if (isa<FriendDecl>(D))
4861 if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) ||
4864 auto *MemberRD = dyn_cast<CXXRecordDecl>(D);
4872 if (MemberRD->isLambda())
4873 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
4877 if (MemberRD->isThisDeclarationADefinition()) {
4883 return {
Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
4913 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
4917 if (NonCLike || ChangesLinkage) {
4918 if (NonCLike.Kind == NonCLikeKind::Invalid)
4921 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
4922 if (ChangesLinkage) {
4924 if (NonCLike.Kind == NonCLikeKind::None)
4925 DiagID = diag::err_typedef_changes_linkage;
4927 DiagID = diag::err_non_c_like_anon_struct_in_typedef;
4933 TextToInsert +=
' ';
4936 Diag(FixitLoc, DiagID)
4939 if (NonCLike.Kind != NonCLikeKind::None) {
4940 Diag(NonCLike.Range.
getBegin(), diag::note_non_c_like_anon_struct)
4941 << NonCLike.Kind - 1 << NonCLike.Range;
4944 << NewTD << isa<TypeAliasDecl>(NewTD);
4967 llvm_unreachable(
"unexpected type specifier");
4978 bool IsExplicitInstantiation,
4980 Decl *TagD =
nullptr;
4995 if (isa<TagDecl>(TagD))
4998 Tag = CTD->getTemplatedDecl();
5003 Tag->setFreeStanding();
5004 if (Tag->isInvalidDecl())
5013 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
5048 bool IsExplicitSpecialization =
5049 !TemplateParams.empty() && TemplateParams.back()->size() == 0;
5050 if (Tag && SS.
isNotEmpty() && !Tag->isCompleteDefinition() &&
5051 !IsExplicitInstantiation && !IsExplicitSpecialization &&
5052 !isa<ClassTemplatePartialSpecializationDecl>(Tag)) {
5061 Diag(SS.
getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
5067 bool DeclaresAnything =
true;
5070 if (
RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
5071 if (!Record->getDeclName() && Record->isCompleteDefinition() &&
5074 Record->getDeclContext()->isRecord()) {
5083 AnonRecord = Record;
5088 DeclaresAnything =
false;
5107 if ((Tag && Tag->getDeclName()) ||
5111 Record = dyn_cast<RecordDecl>(Tag);
5114 Record = RT->getDecl();
5116 Record = UT->getDecl();
5124 DeclaresAnything =
false;
5136 if (
Enum->enumerator_begin() ==
Enum->enumerator_end() &&
5137 !
Enum->getIdentifier() && !
Enum->isInvalidDecl())
5138 DeclaresAnything =
false;
5146 DeclaresAnything =
false;
5150 Tag && Tag->getDeclContext()->isFunctionOrMethod())
5152 << Tag->getTagKind()
5165 if (!DeclaresAnything) {
5168 Diag(DS.
getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty())
5169 ? diag::err_no_declarators
5170 : diag::ext_no_declarators)
5183 unsigned DiagID = diag::warn_standalone_specifier;
5185 DiagID = diag::ext_standalone_specifier;
5226 Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored)
5229 Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored)
5253 assert(PrevDecl &&
"Expected a non-null Decl");
5258 SemaRef.
Diag(NameLoc, diag::err_anonymous_record_member_redecl)
5260 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_previous_declaration);
5288 for (
auto *D : AnonRecord->
decls()) {
5289 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
5290 cast<NamedDecl>(D)->getDeclName()) {
5306 unsigned OldChainingSize = Chaining.size();
5308 Chaining.append(IF->chain_begin(), IF->chain_end());
5310 Chaining.push_back(VD);
5312 assert(Chaining.size() >= 2);
5315 for (
unsigned i = 0; i < Chaining.size(); i++)
5316 NamedChain[i] = Chaining[i];
5320 VD->
getType(), {NamedChain, Chaining.size()});
5332 Chaining.resize(OldChainingSize);
5347 "Parser allowed 'typedef' as storage class VarDecl.");
5348 switch (StorageClassSpec) {
5362 llvm_unreachable(
"unknown storage class specifier");
5366 assert(Record->hasInClassInitializer());
5368 for (
const auto *I : Record->decls()) {
5369 const auto *FD = dyn_cast<FieldDecl>(I);
5370 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
5371 FD = IFD->getAnonField();
5372 if (FD && FD->hasInClassInitializer())
5373 return FD->getLocation();
5376 llvm_unreachable(
"couldn't find in-class initializer");
5381 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5384 S.
Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
5390 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5408 Diag(Record->getLocation(), diag::ext_anonymous_union);
5410 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
5412 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
5418 const char *PrevSpec =
nullptr;
5419 if (Record->isUnion()) {
5429 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
5430 Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
5435 PrevSpec, DiagID, Policy);
5441 isa<RecordDecl>(Owner)) {
5443 diag::err_anonymous_union_with_storage_spec)
5457 << Record->isUnion() <<
"const"
5461 diag::ext_anonymous_struct_union_qualified)
5462 << Record->isUnion() <<
"volatile"
5466 diag::ext_anonymous_struct_union_qualified)
5467 << Record->isUnion() <<
"restrict"
5471 diag::ext_anonymous_struct_union_qualified)
5472 << Record->isUnion() <<
"_Atomic"
5476 diag::ext_anonymous_struct_union_qualified)
5477 << Record->isUnion() <<
"__unaligned"
5487 for (
auto *Mem : Record->decls()) {
5489 if (Mem->isInvalidDecl())
5492 if (
auto *FD = dyn_cast<FieldDecl>(Mem)) {
5496 assert(FD->getAccess() !=
AS_none);
5498 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5499 << Record->isUnion() << (FD->getAccess() ==
AS_protected);
5510 }
else if (Mem->isImplicit()) {
5512 }
else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
5517 }
else if (
auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
5518 if (!MemRecord->isAnonymousStructOrUnion() &&
5519 MemRecord->getDeclName()) {
5522 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
5523 << Record->isUnion();
5526 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
5527 << Record->isUnion();
5534 Diag(MemRecord->getLocation(),
5535 diag::ext_anonymous_record_with_anonymous_type)
5536 << Record->isUnion();
5538 }
else if (isa<AccessSpecDecl>(Mem)) {
5540 }
else if (isa<StaticAssertDecl>(Mem)) {
5545 unsigned DK = diag::err_anonymous_record_bad_member;
5546 if (isa<TypeDecl>(Mem))
5547 DK = diag::err_anonymous_record_with_type;
5548 else if (isa<FunctionDecl>(Mem))
5549 DK = diag::err_anonymous_record_with_function;
5550 else if (isa<VarDecl>(Mem))
5551 DK = diag::err_anonymous_record_with_static;
5555 DK == diag::err_anonymous_record_with_type)
5556 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
5557 << Record->isUnion();
5559 Diag(Mem->getLocation(), DK) << Record->isUnion();
5568 if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
5571 cast<CXXRecordDecl>(Record));
5574 if (!Record->isUnion() && !Owner->
isRecord()) {
5575 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
5595 assert(TInfo &&
"couldn't build declarator info for anonymous struct/union");
5599 if (
RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
5616 Diag(Record->getLocation(), diag::err_mutable_nonmember);
5623 Record->getLocation(),
nullptr,
5635 Record->setAnonymousStructOrUnion(
true);
5646 Chain.push_back(Anon);
5651 if (
VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
5654 Decl *ManglingContextDecl;
5655 std::tie(MCtx, ManglingContextDecl) =
5687 assert(Record &&
"expected a record!");
5692 assert(TInfo &&
"couldn't build declarator info for anonymous struct");
5700 nullptr, RecTy, TInfo,
5712 Chain.push_back(Anon);
5714 RecordDecl *RecordDef = Record->getDefinition();
5716 diag::err_field_incomplete_or_sizeless) ||
5720 ParentDecl->setInvalidDecl();
5736 NameInfo.
setLoc(Name.StartLocation);
5738 switch (Name.getKind()) {
5742 NameInfo.
setName(Name.Identifier);
5758 if (!Template || !isa<ClassTemplateDecl>(Template)) {
5759 Diag(Name.StartLocation,
5760 diag::err_deduction_guide_name_not_class_template)
5763 Diag(Template->getLocation(), diag::note_template_decl_here);
5774 Name.OperatorFunctionId.Operator));
5776 Name.OperatorFunctionId.SymbolLocations[0], Name.EndLocation));
5812 if (!CurClass || CurClass->
getIdentifier() != Name.TemplateId->Name)
5848 llvm_unreachable(
"Unknown name kind");
5876 for (
unsigned Idx = 0; Idx <
Declaration->param_size(); ++Idx) {
5890 (DeclTyName && DeclTyName == DefTyName))
5891 Params.push_back(Idx);
5922 if (T.isNull() || !T->isInstantiationDependentType())
break;
5932 if (!TSI)
return true;
5944 if (
Result.isInvalid())
return true;
5989 << D << static_cast<int>(Status);
6000 if (getOMPTraitInfoForSurroundingScope()->isExtensionActive(llvm::omp::TraitProperty::
6001 implementation_extension_bind_to_declaration))
6029 while (Record && Record->isAnonymousStructOrUnion())
6030 Record = dyn_cast<CXXRecordDecl>(Record->getParent());
6031 if (Record && Record->getIdentifier() && Record->getDeclName() == Name) {
6032 Diag(NameInfo.
getLoc(), diag::err_member_name_of_class) << Name;
6059 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
6073 Diag(Loc,
LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
6074 : diag::err_member_extra_qualification)
6078 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
6086 if (!Cur->
Encloses(DC) && !IsTemplateId) {
6088 Diag(Loc, diag::err_member_qualification)
6090 else if (isa<TranslationUnitDecl>(DC))
6091 Diag(Loc, diag::err_invalid_declarator_global_scope)
6093 else if (isa<FunctionDecl>(Cur))
6094 Diag(Loc, diag::err_invalid_declarator_in_function)
6096 else if (isa<BlockDecl>(Cur))
6097 Diag(Loc, diag::err_invalid_declarator_in_block)
6099 else if (isa<ExportDecl>(Cur)) {
6100 if (!isa<NamespaceDecl>(DC))
6101 Diag(Loc, diag::err_export_non_namespace_scope_name)
6108 Diag(Loc, diag::err_invalid_declarator_scope)
6116 Diag(Loc, diag::err_member_qualification)
6138 if (isa_and_nonnull<DecltypeType>(
6140 Diag(Loc, diag::err_decltype_in_declarator)
6180 if (!DC || isa<EnumDecl>(DC)) {
6186 diag::err_template_qualified_declarator_no_match)
6193 if (!IsDependentContext &&
6198 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->
hasDefinition()) {
6200 diag::err_member_def_undefined_record)
6217 if (EnteringContext && IsDependentContext &&
6218 TemplateParamLists.size() != 0) {
6237 bool IsLinkageLookup =
false;
6238 bool CreateBuiltins =
false;
6252 IsLinkageLookup =
true;
6257 CreateBuiltins =
true;
6259 if (IsLinkageLookup) {
6298 Previous.getFoundDecl()->isTemplateParameter()) {
6328 bool AddToScope =
true;
6330 if (TemplateParamLists.size()) {
6364 bool &SizeIsNegative,
6365 llvm::APSInt &Oversized) {
6370 SizeIsNegative =
false;
6373 if (T->isDependentType())
6379 if (
const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
6384 if (FixedType.
isNull())
return FixedType;
6386 return Qs.
apply(Context, FixedType);
6388 if (
const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
6389 QualType Inner = PTy->getInnerType();
6393 if (FixedType.
isNull())
return FixedType;
6395 return Qs.
apply(Context, FixedType);
6405 SizeIsNegative, Oversized);
6415 llvm::APSInt Res =
Result.Val.getInt();
6418 if (Res.isSigned() && Res.isNegative()) {
6419 SizeIsNegative =
true;
6424 unsigned ActiveSizeBits =
6428 : Res.getActiveBits();
6436 return Qs.
apply(Context, FoldedArrayType);
6461 TypeLoc DstElemTL = DstATL.getElementLoc();
6480 bool &SizeIsNegative,
6481 llvm::APSInt &Oversized) {
6484 SizeIsNegative, Oversized);
6497 unsigned FailedFoldDiagID) {
6498 bool SizeIsNegative;
6499 llvm::APSInt Oversized;
6501 TInfo,
Context, SizeIsNegative, Oversized);
6503 Diag(Loc, diag::ext_vla_folded_to_constant);
6510 Diag(Loc, diag::err_typecheck_negative_array_size);
6511 else if (Oversized.getBoolValue())
6512 Diag(Loc, diag::err_array_too_large) <<
toString(Oversized, 10);
6513 else if (FailedFoldDiagID)
6514 Diag(Loc, FailedFoldDiagID);
6546 diag::err_virtual_non_function);
6550 diag::err_explicit_non_function);
6554 diag::err_noreturn_non_function);
6577 << 1 <<
static_cast<int>(D.
getDeclSpec().getConstexprSpecifier());
6582 diag::err_deduction_guide_invalid_specifier)
6591 if (!NewTD)
return nullptr;
6612 if (T->isVariablyModifiedType()) {
6615 if (S->getFnParent() ==
nullptr) {
6616 bool SizeIsNegative;
6617 llvm::APSInt Oversized;
6628 else if (T->isVariableArrayType())
6630 else if (Oversized.getBoolValue())
6657 Redeclaration =
true;
6663 if (ShadowedDecl && !Redeclaration)
6670 if (II->isStr(
"FILE"))
6672 else if (II->isStr(
"jmp_buf"))
6674 else if (II->isStr(
"sigjmp_buf"))
6676 else if (II->isStr(
"ucontext_t"))
6734 if (!OuterContext->
Equals(PrevOuterContext))
6743 if (!SS.
isSet())
return;
6752 unsigned kind = -1U;
6754 if (var->hasAttr<BlocksAttr>())
6756 else if (!var->hasLocalStorage())
6758 }
else if (isa<ObjCIvarDecl>(
decl)) {
6760 }
else if (isa<FieldDecl>(
decl)) {
6765 Diag(
decl->getLocation(), diag::err_arc_autoreleasing_var)
6770 if (!type->isObjCLifetimeType())
6773 lifetime = type->getObjCARCImplicitLifetime();
6775 decl->setType(type);
6781 var->getTLSKind()) {
6782 Diag(var->getLocation(), diag::err_arc_thread_ownership)
6792 if (
Decl->getType().hasAddressSpace())
6794 if (
Decl->getType()->isDependentType())
6806 Var->hasGlobalStorage())
6810 if (
auto DT = dyn_cast<DecayedType>(
Type)) {
6811 auto OrigTy = DT->getOriginalType();
6812 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) {
6844 if (WeakRefAttr *
Attr = ND.
getAttr<WeakRefAttr>()) {
6852 if (
auto *VD = dyn_cast<VarDecl>(&ND)) {
6853 if (VD->hasInit()) {
6854 if (
const auto *
Attr = VD->getAttr<AliasAttr>()) {
6855 assert(VD->isThisDeclarationADefinition() &&
6856 !VD->isExternallyVisible() &&
"Broken AliasAttr handled late!");
6858 VD->dropAttr<AliasAttr>();
6865 if (SelectAnyAttr *
Attr = ND.
getAttr<SelectAnyAttr>()) {
6868 diag::err_attribute_selectany_non_extern_data);
6874 auto *VD = dyn_cast<VarDecl>(&ND);
6875 bool IsAnonymousNS =
false;
6878 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext());
6879 while (NS && !IsAnonymousNS) {
6881 NS = dyn_cast<NamespaceDecl>(NS->
getParent());
6888 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft;
6890 (!AnonNSInMicrosoftMode &&
6899 if (
const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
6904 for (
TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
6910 if (
const auto *A = ATL.
getAttrAs<LifetimeBoundAttr>()) {
6911 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
6912 if (!MD || MD->isStatic()) {
6913 S.
Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
6914 << !MD << A->getRange();
6915 }
else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) {
6916 S.
Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
6926 bool IsSpecialization,
6927 bool IsDefinition) {
6931 bool IsTemplate =
false;
6932 if (
TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
6933 OldDecl = OldTD->getTemplatedDecl();
6935 if (!IsSpecialization)
6936 IsDefinition =
false;
6938 if (
TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
6939 NewDecl = NewTD->getTemplatedDecl();
6943 if (!OldDecl || !NewDecl)
6946 const DLLImportAttr *OldImportAttr = OldDecl->
getAttr<DLLImportAttr>();
6947 const DLLExportAttr *OldExportAttr = OldDecl->
getAttr<DLLExportAttr>();
6948 const DLLImportAttr *NewImportAttr = NewDecl->
getAttr<DLLImportAttr>();
6949 const DLLExportAttr *NewExportAttr = NewDecl->
getAttr<DLLExportAttr>();
6953 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
6954 (NewExportAttr && !NewExportAttr->isInherited());
6960 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
6962 if (AddsAttr && !IsSpecialization && !OldDecl->
isImplicit()) {
6964 bool JustWarn =
false;
6966 auto *VD = dyn_cast<VarDecl>(OldDecl);
6967 if (VD && !VD->getDescribedVarTemplate())
6969 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
6978 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
6981 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
6982 : diag::err_attribute_dll_redeclaration;
6985 << (NewImportAttr ? (
const Attr *)NewImportAttr : NewExportAttr);
6998 bool IsInline =
false, IsStaticDataMember =
false, IsQualifiedFriend =
false;
7000 if (
const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
7003 IsStaticDataMember = VD->isStaticDataMember();
7004 IsDefinition = VD->isThisDeclarationADefinition(S.
Context) !=
7006 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
7007 IsInline = FD->isInlined();
7008 IsQualifiedFriend = FD->getQualifier() &&
7012 if (OldImportAttr && !HasNewAttr &&
7013 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
7015 if (IsMicrosoftABI && IsDefinition) {
7017 diag::warn_redeclaration_without_import_attribute)
7020 NewDecl->
dropAttr<DLLImportAttr>();
7022 DLLExportAttr::CreateImplicit(S.
Context, NewImportAttr->getRange()));
7025 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
7026 << NewDecl << OldImportAttr;
7028 S.
Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
7029 OldDecl->
dropAttr<DLLImportAttr>();
7030 NewDecl->
dropAttr<DLLImportAttr>();
7032 }
else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
7035 OldDecl->
dropAttr<DLLImportAttr>();
7036 NewDecl->
dropAttr<DLLImportAttr>();
7038 diag::warn_dllimport_dropped_from_inline_function)
7039 << NewDecl << OldImportAttr;
7046 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
7048 !NewImportAttr && !NewExportAttr) {
7049 if (
const DLLExportAttr *ParentExportAttr =
7050 MD->getParent()->getAttr<DLLExportAttr>()) {
7051 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.
Context);
7052 NewAttr->setInherited(
true);
7104 return D->isExternC();
7110 isa<OMPDeclareMapperDecl>(DC))
7116 if (isa<RequiresExprBodyDecl>(DC))
7118 llvm_unreachable(
"Unexpected context");
7124 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC))
7128 llvm_unreachable(
"Unexpected context");
7175 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
7176 return FD->isExternC();
7177 if (
const auto *VD = dyn_cast<VarDecl>(D))
7178 return VD->isExternC();
7180 llvm_unreachable(
"Unknown type of decl!");
7193 diag::err_opencl_type_can_only_be_used_as_function_parameter)
7207 diag::err_invalid_type_for_program_scope_var)
7236 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_half_declaration) << R;
7269 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_nonconst_global_sampler);
7279template <
typename AttrTy>
7282 if (
const auto *Attribute = TND->
getAttr<AttrTy>()) {
7283 AttrTy *Clone = Attribute->clone(S.
Context);
7284 Clone->setInherited(
true);
7302 if (!Decomp.bindings().empty()) {
7303 II = Decomp.bindings()[0].Name;
7323 bool IsLocalExternDecl = SC ==
SC_Extern &&
7342 : diag::warn_deprecated_register)
7348 if (!DC->
isRecord() && S->getFnParent() ==
nullptr) {
7364 bool IsMemberSpecialization =
false;
7365 bool IsVariableTemplateSpecialization =
false;
7367 bool IsVariableTemplate =
false;
7395 diag::err_static_out_of_line)
7407 diag::err_storage_class_for_static_member)
7411 llvm_unreachable(
"C storage class in c++!");
7416 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
7422 if (Ctxt->isFunctionOrMethod()) {
7423 FunctionOrMethod = Ctxt;
7426 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt);
7428 AnonStruct = ParentDecl;
7432 if (FunctionOrMethod) {
7436 diag::err_static_data_member_not_allowed_in_local_class)
7437 << Name << RD->getDeclName() << RD->getTagKind();
7438 }
else if (AnonStruct) {
7443 diag::err_static_data_member_not_allowed_in_anon_struct)
7446 }
else if (RD->isUnion()) {
7451 ? diag::warn_cxx98_compat_static_data_member_in_union
7452 : diag::ext_static_data_member_in_union) << Name;
7459 bool InvalidScope =
false;
7467 false, IsMemberSpecialization, InvalidScope);
7470 if (TemplateParams) {
7471 if (!TemplateParams->
size() &&
7476 diag::err_template_variable_noparams)
7480 TemplateParams =
nullptr;
7488 IsVariableTemplateSpecialization =
true;
7492 IsVariableTemplate =
true;
7497 ? diag::warn_cxx11_compat_variable_template
7498 : diag::ext_variable_template);
7503 if (!TemplateParamLists.empty() && IsMemberSpecialization &&
7508 "should have a 'template<>' for this decl");
7511 if (IsVariableTemplateSpecialization) {
7513 TemplateParamLists.size() > 0
7514 ? TemplateParamLists[0]->getTemplateLoc()
7517 S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
7532 if (IsVariableTemplate) {
7535 TemplateParams, NewVD);
7554 unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
7555 if (TemplateParamLists.size() > VDTemplateParamLists)
7557 Context, TemplateParamLists.drop_back(VDTemplateParamLists));
7567 diag::err_inline_declaration_block_scope) << Name
7572 : diag::ext_inline_variable);
7583 if (IsLocalExternDecl) {
7586 B->setLocalExternDecl();
7591 bool EmitTLSUnsupportedError =
false;
7604 diag::err_thread_non_global)
7612 EmitTLSUnsupportedError =
true;
7619 diag::err_thread_unsupported);
7630 diag::err_constexpr_wrong_decl_kind)
7631 <<
static_cast<int>(D.
getDeclSpec().getConstexprSpecifier());
7648 diag::err_constinit_local_variable);
7650 NewVD->
addAttr(ConstInitAttr::Create(
7665 if (SC ==
SC_Static && S->getFnParent() !=
nullptr &&
7670 diag::warn_static_local_in_extern_inline);
7676 if (IsVariableTemplateSpecialization)
7681 else if (IsMemberSpecialization)
7696 B->setModulePrivate();
7706 diag::err_opencl_unknown_type_specifier)
7726 if (EmitTLSUnsupportedError &&
7729 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(NewVD))))
7731 diag::err_thread_unsupported);
7733 if (EmitTLSUnsupportedError &&
7738 if (SC ==
SC_None && S->getFnParent() !=
nullptr &&
7739 (NewVD->
hasAttr<CUDASharedAttr>() ||
7740 NewVD->
hasAttr<CUDAConstantAttr>())) {
7748 assert(!NewVD->
hasAttr<DLLImportAttr>() ||
7749 NewVD->
getAttr<DLLImportAttr>()->isInherited() ||
7762 if (S->getFnParent() !=
nullptr) {
7766 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) <<
Label;
7772 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
7783 bool HasSizeMismatch;
7785 if (!TI.isValidGCCRegisterName(
Label))
7786 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
7787 else if (!TI.validateGlobalRegisterVariable(
Label,
7790 Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) <<
Label;
7791 else if (HasSizeMismatch)
7792 Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) <<
Label;
7805 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
7827 IsMemberSpecialization ||
7828 IsVariableTemplateSpecialization);
7849 isa<FieldDecl>(
Previous.getFoundDecl()) &&
7866 if (!IsVariableTemplateSpecialization)
7890 if (PrevVarTemplate &&
7910 Decl *ManglingContextDecl;
7911 std::tie(MCtx, ManglingContextDecl) =
7922 if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr(
"main") &&
7970 if (isa<TypeAliasDecl>(ShadowedDecl))
7972 else if (isa<TypedefDecl>(ShadowedDecl))
7974 else if (isa<BindingDecl>(ShadowedDecl))
7976 else if (isa<RecordDecl>(OldDC))
8059 if (
FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
8067 if (isa<CXXConstructorDecl>(NewDC))
8068 if (
const auto PVD = dyn_cast<ParmVarDecl>(D)) {
8071 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
8076 if (
VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
8077 if (shadowedVar->isExternC()) {
8080 for (
auto I : shadowedVar->redecls())
8081 if (I->isFileVarDecl()) {
8089 unsigned WarningDiag = diag::warn_decl_shadow;
8091 if (isa<VarDecl>(D) && isa<VarDecl>(ShadowedDecl) && NewDC &&
8092 isa<CXXMethodDecl>(NewDC)) {
8093 if (
const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->
getParent())) {
8095 if (RD->getLambdaCaptureDefault() ==
LCD_None) {
8101 WarningDiag = diag::warn_decl_shadow_uncaptured_local;
8106 ->ShadowingDecls.push_back(
8112 if (cast<VarDecl>(ShadowedDecl)->hasLocalStorage()) {
8116 ParentDC && !ParentDC->
Equals(OldDC);
8120 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
8150 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8159 const VarDecl *ShadowedDecl = Shadow.ShadowedDecl;
8164 ? diag::warn_decl_shadow_uncaptured_local
8165 : diag::warn_decl_shadow)
8166 << Shadow.VD->getDeclName()
8169 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8170 << Shadow.VD->getDeclName() << 0;
8194 auto *DRE = dyn_cast<DeclRefExpr>(E);
8198 auto I = ShadowingDecls.find(D);
8199 if (I == ShadowingDecls.end())
8201 const NamedDecl *ShadowedDecl = I->second;
8203 Diag(Loc, diag::warn_modifying_shadowing_decl) << D << OldDC;
8208 ShadowingDecls.erase(I);
8216 assert(S.
getLangOpts().CPlusPlus &&
"only C++ has extern \"C\"");
8237 if (!isa<VarDecl>(ND))
8247 if (isa<VarDecl>(*I)) {
8257 if (isa<VarDecl>(*I)) {
8275 assert(Prev &&
"should have found a previous declaration to diagnose");
8277 Prev = FD->getFirstDecl();
8281 S.
Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
8303 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8315 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
8336 if (T->isUndeducedType())
8342 if (T->isObjCObjectType()) {
8376 if (NewVD->
hasAttr<BlocksAttr>()) {
8381 if (T->isBlockPointerType()) {
8384 if (!T.isConstQualified()) {
8385 Diag(NewVD->
getLocation(), diag::err_opencl_invalid_block_declaration)
8391 Diag(NewVD->
getLocation(), diag::err_opencl_extern_block_declaration);
8400 if (!T->isSamplerT() && !T->isDependentType() &&
8407 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8408 <<
Scope <<
"global or constant";
8410 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8411 <<
Scope <<
"constant";
8427 if (FD && !FD->
hasAttr<OpenCLKernelAttr>()) {
8439 if (FD && FD->
hasAttr<OpenCLKernelAttr>()) {
8464 && !NewVD->
hasAttr<BlocksAttr>()) {
8473 bool isVM = T->isVariablyModifiedType();
8474 if (isVM || NewVD->
hasAttr<CleanupAttr>() ||
8480 bool SizeIsNegative;
8481 llvm::APSInt Oversized;
8486 FixedT = FixedTInfo->
getType();
8487 else if (FixedTInfo) {
8493 if ((!FixedTInfo || FixedT.
isNull()) && T->isVariableArrayType()) {
8526 if (T->isVoidType()) {
8549 if (isVM && NewVD->
hasAttr<BlocksAttr>()) {
8555 if (NewVD->
isConstexpr() && !T->isDependentType() &&
8557 diag::err_constexpr_var_non_literal)) {
8612 CXXRecordDecl *BaseRecord = Specifier->getType()->getAsCXXRecordDecl();
8624 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
8633 if (Overridden.insert(BaseMD).second) {
8650 return !Overridden.empty();
8656 struct ActOnFDArgs {
8672 : Context(Context), OriginalFD(TypoFD),
8675 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
8681 CDeclEnd = candidate.
end();
8682 CDecl != CDeclEnd; ++CDecl) {
8689 if (
Parent &&
Parent->getCanonicalDecl() == ExpectedParent)
8691 }
else if (!ExpectedParent) {
8700 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
8701 return std::make_unique<DifferentNameValidatorCCC>(*
this);
8727 ActOnFDArgs &ExtraArgs,
bool IsLocalFriend,
Scope *S) {
8735 IsLocalFriend ? diag::err_no_matching_local_friend :
8737 diag::err_member_decl_does_not_match;
8749 "Cannot have an ambiguity in previous-declaration lookup");
8751 DifferentNameValidatorCCC CCC(SemaRef.
Context, NewFD,
8753 if (!Prev.
empty()) {
8755 Func != FuncEnd; ++Func) {
8762 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
8763 NearMatches.push_back(std::make_pair(FD, ParamNum));
8770 IsLocalFriend ?
nullptr : NewDC))) {
8777 CDeclEnd = Correction.
end();
8778 CDecl != CDeclEnd; ++CDecl) {
8798 ExtraArgs.S, ExtraArgs.D,
8801 ExtraArgs.AddToScope);
8812 if ((*I)->getCanonicalDecl() == Canonical)
8819 SemaRef.
PDiag(IsLocalFriend
8820 ? diag::err_no_matching_local_friend_suggest
8821 : diag::err_member_decl_does_not_match_suggest)
8822 << Name << NewDC << IsDefinition);
8835 << Name << NewDC << IsDefinition << NewFD->
getLocation();
8837 bool NewFDisConst =
false;
8839 NewFDisConst = NewMD->isConst();
8842 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
8843 NearMatch != NearMatchEnd; ++NearMatch) {
8846 bool FDisConst = MD && MD->
isConst();
8847 bool IsMember = MD || !IsLocalFriend;
8850 if (
unsigned Idx = NearMatch->second) {
8854 SemaRef.
Diag(Loc, IsMember ? diag::note_member_def_close_param_match
8855 : diag::note_local_decl_close_param_match)
8858 }
else if (FDisConst != NewFDisConst) {
8859 SemaRef.
Diag(FD->
getLocation(), diag::note_member_def_close_const_match)
8870 IsMember ? diag::note_member_def_close_match
8871 : diag::note_local_decl_close_match);
8878 default: llvm_unreachable(
"Unknown storage class!");
8883 diag::err_typecheck_sclass_func);
8900 diag::err_static_block_func);
8916 bool &IsVirtualOkay) {
8941 "Strict prototypes are required");
8959 diag::err_constexpr_wrong_decl_kind)
8960 <<
static_cast<int>(ConstexprKind);
8978 "Constructors can only be declared in a member context");
8984 isInline,
false, ConstexprKind,
8995 false, ConstexprKind,
8996 TrailingRequiresClause);
8999 if (Record->isBeingDefined())
9008 IsVirtualOkay =
true;
9020 true, ConstexprKind, TrailingRequiresClause);
9026 diag::err_conv_function_not_member);
9034 IsVirtualOkay =
true;
9039 TrailingRequiresClause);
9042 if (TrailingRequiresClause)
9044 diag::err_trailing_requires_clause_on_deduction_guide)
9056 if (Name.getAsIdentifierInfo() &&
9057 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
9069 IsVirtualOkay = !
Ret->isStatic();
9083 true , ConstexprKind, TrailingRequiresClause);
9100 StringRef SizeTypeNames[] = {
"size_t",
"intptr_t",
"uintptr_t",
"ptrdiff_t"};
9108 if (Names.end() != Match)
9113 }
while (DesugaredTy != Ty);
9146 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts()) &&
9190 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts()) &&
9204 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
9218 S.
Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
9231 S.
Diag(Param->getLocation(), diag::err_kernel_arg_address_space);
9248 S.
Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
9256 S.
Diag(Loc, diag::note_entity_declared_at) << PT;
9257 PT = Typedef->desugar();
9279 HistoryStack.push_back(
nullptr);
9288 VisitStack.push_back(RecTy->
getDecl());
9289 assert(VisitStack.back() &&
"First decl null?");
9292 const Decl *
Next = VisitStack.pop_back_val();
9294 assert(!HistoryStack.empty());
9296 if (
const FieldDecl *Hist = HistoryStack.pop_back_val())
9297 ValidTypes.insert(Hist->getType().getTypePtr());
9306 HistoryStack.push_back(Field);
9308 QualType FieldTy = Field->getType();
9312 "Unexpected type.");
9321 VisitStack.push_back(
nullptr);
9323 for (
const auto *FD : RD->
fields()) {
9334 VisitStack.push_back(FD);
9344 S.
Diag(Param->getLocation(),
9345 diag::err_record_with_pointers_kernel_param)
9349 S.
Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
9352 S.
Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
9353 << OrigRecDecl->getDeclName();
9358 I = HistoryStack.begin() + 1,
9359 E = HistoryStack.end();
9372 }
while (!VisitStack.empty());
9388 while (S->isClassScope() ||
9389 (LangOpts.CPlusPlus &&
9390 S->isFunctionPrototypeScope()) ||
9392 (S->getEntity() && S->getEntity()->isTransparentContext()))
9399 unsigned BuiltinID) {
9400 switch (BuiltinID) {
9401 case Builtin::BI__GetExceptionInfo:
9405 case Builtin::BIaddressof:
9406 case Builtin::BI__addressof:
9407 case Builtin::BIforward:
9408 case Builtin::BImove:
9409 case Builtin::BImove_if_noexcept:
9410 case Builtin::BIas_const: {
9435 llvm::append_range(TemplateParamLists, TemplateParamListsRef);
9437 if (!TemplateParamLists.empty() &&
9438 Invented->getDepth() == TemplateParamLists.back()->getDepth())
9439 TemplateParamLists.back() = Invented;
9441 TemplateParamLists.push_back(Invented);
9451 diag::err_invalid_thread)
9458 bool isFriend =
false;
9460 bool isMemberSpecialization =
false;
9461 bool isFunctionTemplateSpecialization =
false;
9463 bool isDependentClassScopeExplicitSpecialization =
false;
9464 bool HasExplicitTemplateArgs =
false;
9467 bool isVirtualOkay =
false;
9474 if (!NewFD)
return nullptr;
9484 if (IsLocalExternDecl)
9493 bool ImplicitInlineCXX20 = !
getLangOpts().CPlusPlusModules ||
9516 if (
Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9521 if (isVirtual &&
Parent->isUnion()) {
9526 Parent->hasAttr<SYCLSpecialClassAttr>() &&
9529 if (
auto *Def =
Parent->getDefinition())
9530 Def->setInitMethod(
true);
9535 isMemberSpecialization =
false;
9536 isFunctionTemplateSpecialization =
false;
9550 TemplateParamLists, isFriend, isMemberSpecialization,
9552 if (TemplateParams) {
9557 if (TemplateParams->
size() > 0) {
9577 Name, TemplateParams,
9583 if (TemplateParamLists.size() > 1) {
9590 isFunctionTemplateSpecialization =
true;
9592 if (TemplateParamLists.size() > 0)
9612 << Name << RemoveRange
9620 if (!TemplateParamLists.empty() && isMemberSpecialization &&
9626 if (TemplateParamLists.size() > 0)
9643 if (!isVirtualOkay) {
9645 diag::err_virtual_non_function);
9649 diag::err_virtual_out_of_class)
9655 diag::err_virtual_member_function_template)
9691 diag::err_inline_declaration_block_scope) << Name
9701 !isa<CXXDeductionGuideDecl>(NewFD)) {
9705 diag::err_explicit_out_of_class)
9707 }
else if (!isa<CXXConstructorDecl>(NewFD) &&
9708 !isa<CXXConversionDecl>(NewFD)) {
9712 diag::err_explicit_non_ctor_or_conv_function)
9726 if (isa<CXXDestructorDecl>(NewFD) &&
9730 <<
static_cast<int>(ConstexprKind);
9744 diag::err_invalid_consteval_decl_kind)
9752 if (isFunctionTemplateSpecialization) {
9755 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
9790 if (isa<CXXMethodDecl>(NewFD) && DC ==
CurContext &&
9801 if (SC ==
SC_Static && isa<CXXMethodDecl>(NewFD) &&
9816 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) ||
9818 ? diag::ext_static_out_of_line : diag::err_static_out_of_line)
9826 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
9827 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
9837 isMemberSpecialization ||
9838 isFunctionTemplateSpecialization);
9848 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
9873 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
9875 assert(Param->getDeclContext() != NewFD &&
"Was set before ?");
9876 Param->setDeclContext(NewFD);
9877 Params.push_back(Param);
9879 if (Param->isInvalidDecl())
9892 auto *TD = dyn_cast<TagDecl>(NonParmDecl);
9897 if (
auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
9906 TD->setDeclContext(NewFD);
9914 if (TagDC != PrototypeTagContext)
9915 TD->setLexicalDeclContext(TagDC);
9929 for (
const auto &AI : FT->param_types()) {
9932 Param->setScopeInfo(0, Params.size());
9933 Params.push_back(Param);
9937 "Should not need args for typedef of non-prototype fn");
9941 NewFD->setParams(Params);
9958 !NewFD->
hasAttr<SectionAttr>())
9959 NewFD->
addAttr(PragmaClangTextSectionAttr::CreateImplicit(
9965 !NewFD->
hasAttr<SectionAttr>()) {
9966 NewFD->
addAttr(SectionAttr::CreateImplicit(
9969 SectionAttr::Declspec_allocate));
9979 if (!NewFD->
hasAttr<CodeSegAttr>()) {
9995 diag::err_opencl_return_value_with_address_space);
10010 isMemberSpecialization,
10017 "previous declaration set still overloaded");
10029 CC ==
CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
10052 diag::ext_operator_new_delete_declared_inline)
10066 HasExplicitTemplateArgs =
true;
10069 HasExplicitTemplateArgs =
false;
10075 HasExplicitTemplateArgs =
false;
10077 assert((isFunctionTemplateSpecialization ||
10079 "should have a 'template<>' for this decl");
10081 isFunctionTemplateSpecialization =
true;
10083 }
else if (isFriend && isFunctionTemplateSpecialization) {
10090 HasExplicitTemplateArgs =
true;
10108 if (isFunctionTemplateSpecialization && isFriend &&
10112 assert(HasExplicitTemplateArgs &&
10113 "friend function specialization without template args");
10117 }
else if (isFunctionTemplateSpecialization) {
10120 isDependentClassScopeExplicitSpecialization =
true;
10123 NewFD, (HasExplicitTemplateArgs ? &TemplateArgs :
nullptr),
10135 diag::err_explicit_specialization_inconsistent_storage_class)
10142 diag::ext_explicit_specialization_storage_class)
10146 }
else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
10152 if (!isDependentClassScopeExplicitSpecialization) {
10161 isMemberSpecialization,
10170 "previous declaration set still overloaded");
10211 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
10257 *
this,
Previous, NewFD, ExtraArgs,
false,
nullptr)) {
10258 AddToScope = ExtraArgs.AddToScope;
10265 }
else if (isFriend && cast<CXXRecordDecl>(
CurContext)->isLocalClass()) {
10267 *
this,
Previous, NewFD, ExtraArgs,
true, S)) {
10268 AddToScope = ExtraArgs.AddToScope;
10273 isa<CXXMethodDecl>(NewFD) && NewFD->
isOutOfLine() &&
10274 !isFriend && !isFunctionTemplateSpecialization &&
10275 !isMemberSpecialization) {
10292 if (
unsigned BuiltinID = II->getBuiltinID()) {
10294 if (!InStdNamespace &&
10300 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10309 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10314 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10325 if (NewFD->
hasAttr<OverloadableAttr>() &&
10328 diag::err_attribute_overloadable_no_prototype)
10335 EPI.Variadic =
true;
10336 EPI.ExtInfo = FT->getExtInfo();
10372 isMemberSpecialization ||
10373 isFunctionTemplateSpecialization,
10392 (NewFD->
hasAttr<CUDADeviceAttr>() ||
10393 NewFD->
hasAttr<CUDAGlobalAttr>()) &&
10452 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
10454 QualType ElemTy = PipeTy->getElementType();
10456 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
10466 if (isDependentClassScopeExplicitSpecialization) {
10470 cast<CXXMethodDecl>(NewFD),
10471 HasExplicitTemplateArgs, TemplateArgs);
10473 AddToScope =
false;
10478 if (
const auto *
attr = NewFD->
getAttr<AvailabilityAttr>()) {
10479 if (NewFD->
hasAttr<ConstructorAttr>()) {
10480 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10482 NewFD->
dropAttr<AvailabilityAttr>();
10484 if (NewFD->
hasAttr<DestructorAttr>()) {
10485 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10487 NewFD->
dropAttr<AvailabilityAttr>();
10498 if (
const auto *NBA = NewFD->
getAttr<NoBuiltinAttr>())
10502 Diag(NBA->getLocation(),
10503 diag::err_attribute_no_builtin_on_defaulted_deleted_function)
10504 << NBA->getSpelling();
10507 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition)
10508 << NBA->getSpelling();
10528 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
10532 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
10543 while ((
Parent = dyn_cast<CXXRecordDecl>(
Parent->getParent()))) {
10544 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
10563 bool IsDefinition) {
10566 if (!FD->
hasAttr<SectionAttr>() && IsDefinition &&
10568 return SectionAttr::CreateImplicit(
10571 SectionAttr::Declspec_allocate);
10636 auto *VD = dyn_cast<ValueDecl>(D);
10637 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
10638 return !VD || !PrevVD ||
10640 PrevVD->getType());
10648 const auto *TA = FD->
getAttr<TargetAttr>();
10649 assert(TA &&
"MultiVersion Candidate requires a target attribute");
10652 enum ErrType { Feature = 0, Architecture = 1 };
10661 for (
const auto &Feat : ParseInfo.
Features) {
10662 auto BareFeat = StringRef{Feat}.substr(1);
10663 if (Feat[0] ==
'-') {
10665 << Feature << (
"no-" + BareFeat).str();
10672 << Feature << BareFeat;
10690 case attr::NonNull:
10691 case attr::NoThrow:
10700 const auto Diagnose = [FD, CausedFD, MVKind](
Sema &S,
const Attr *A) {
10701 S.
Diag(FD->
getLocation(), diag::err_multiversion_disallowed_other_attr)
10702 <<
static_cast<unsigned>(MVKind) << A;
10704 S.
Diag(CausedFD->
getLocation(), diag::note_multiversioning_caused_here);
10709 switch (A->getKind()) {
10710 case attr::CPUDispatch:
10711 case attr::CPUSpecific:
10714 return Diagnose(S, A);
10718 return Diagnose(S, A);
10720 case attr::TargetClones:
10722 return Diagnose(S, A);
10726 return Diagnose(S, A);
10739 bool ConstexprSupported,
bool CLinkageMayDiffer) {
10740 enum DoesntSupport {
10747 DefaultedFuncs = 6,
10748 ConstexprFuncs = 7,
10749 ConstevalFuncs = 8,
10761 if (NoProtoDiagID.
getDiagID() != 0 && OldFD &&
10764 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
10772 if (!TemplatesSupported &&
10774 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10777 if (
const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
10778 if (NewCXXFD->isVirtual())
10779 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10782 if (isa<CXXConstructorDecl>(NewCXXFD))
10783 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10786 if (isa<CXXDestructorDecl>(NewCXXFD))
10787 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10792 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10796 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10800 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10801 << (NewFD->
isConsteval() ? ConstevalFuncs : ConstexprFuncs);
10805 QualType NewReturnType = NewType->getReturnType();
10808 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
10818 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC())
10821 QualType OldReturnType = OldType->getReturnType();
10823 if (OldReturnType != NewReturnType)
10824 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
10827 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
10830 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
10833 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) <<
Linkage;
10857 bool IsCPUSpecificCPUDispatchMVKind =
10861 if (CausesMV && OldFD &&
10869 if (OldFD && CausesMV && OldFD->
isUsed(
false))
10870 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
10873 OldFD, NewFD, S.
PDiag(diag::err_multiversion_noproto),
10875 S.
PDiag(diag::note_multiversioning_caused_here)),
10877 S.
PDiag(diag::err_multiversion_doesnt_support)
10878 <<
static_cast<unsigned>(MVKind)),
10880 S.
PDiag(diag::err_multiversion_diff)),
10882 !IsCPUSpecificCPUDispatchMVKind,
10894 const TargetAttr *TA) {
10896 "Function lacks multiversion attribute");
10929 const auto *OldTA = OldFD->
getAttr<TargetAttr>();
10932 llvm::sort(NewParsed.Features);
10936 if (!NewTA->isDefaultVersion() &&
10937 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr()))
10953 if (!OldFD->
isMultiVersion() && !OldTA && NewTA->isDefaultVersion()) {
10954 Redeclaration =
true;
10962 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
10969 if (OldParsed == NewParsed) {
10976 for (
const auto *FD : OldFD->
redecls()) {
10977 const auto *CurTA = FD->
getAttr<TargetAttr>();
10981 (!CurTA || CurTA->isInherited())) {
10984 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
10992 Redeclaration =
false;
11015 const CPUDispatchAttr *NewCPUDisp,
const CPUSpecificAttr *NewCPUSpec,
11016 const TargetClonesAttr *NewClones,
bool &Redeclaration,
NamedDecl *&OldDecl,
11030 NewParsed = NewTA->parse();
11034 bool UseMemberUsingDeclRules =
11037 bool MayNeedOverloadableChecks =
11046 if (MayNeedOverloadableChecks &&
11047 S.
IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11050 switch (NewMVKind) {
11053 "Only target_clones can be omitted in subsequent declarations");
11056 const auto *CurTA = CurFD->
getAttr<TargetAttr>();
11057 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
11059 Redeclaration =
true;
11065 if (CurParsed == NewParsed) {
11074 const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>();
11075 Redeclaration =
true;
11079 if (CurClones && NewClones &&
11080 (CurClones->featuresStrs_size() != NewClones->featuresStrs_size() ||
11081 !std::equal(CurClones->featuresStrs_begin(),
11082 CurClones->featuresStrs_end(),
11083 NewClones->featuresStrs_begin()))) {
11094 const auto *CurCPUSpec = CurFD->
getAttr<CPUSpecificAttr>();
11095 const auto *CurCPUDisp = CurFD->
getAttr<CPUDispatchAttr>();
11100 CurFD->
hasAttr<CPUDispatchAttr>()) {
11101 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
11103 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
11104 NewCPUDisp->cpus_begin(),
11106 return Cur->getName() == New->getName();
11109 Redeclaration =
true;
11121 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
11123 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
11124 NewCPUSpec->cpus_begin(),
11126 return Cur->getName() == New->getName();
11129 Redeclaration =
true;
11137 if (CurII == NewII) {
11171 Redeclaration =
true;
11177 Redeclaration =
false;
11190 bool &Redeclaration,
NamedDecl *&OldDecl,
11192 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11193 const auto *NewCPUDisp = NewFD->
getAttr<CPUDispatchAttr>();
11194 const auto *NewCPUSpec = NewFD->
getAttr<CPUSpecificAttr>();
11195 const auto *NewClones = NewFD->
getAttr<TargetClonesAttr>();
11203 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_not_allowed_on_main);
11229 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_required_in_redecl)
11239 Redeclaration, OldDecl,
Previous);
11241 if (OldFD->
isUsed(
false)) {
11243 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11258 NewCPUDisp, NewCPUSpec, NewClones,
11259 Redeclaration, OldDecl,
Previous);
11281 bool IsMemberSpecialization,
11284 "Variably modified return types are not handled here");
11289 bool MergeTypeWithPrevious = !
getLangOpts().CPlusPlus &&
11292 bool Redeclaration =
false;
11294 bool MayNeedOverloadableChecks =
false;
11305 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
11306 Redeclaration =
true;
11307 OldDecl = Candidate;
11310 MayNeedOverloadableChecks =
true;
11314 Redeclaration =
true;
11318 Redeclaration =
true;
11322 Redeclaration =
false;
11329 if (!Redeclaration &&
11334 Redeclaration =
true;
11335 OldDecl =
Previous.getFoundDecl();
11336 MergeTypeWithPrevious =
false;
11339 if (OldDecl->
hasAttr<OverloadableAttr>() ||
11340 NewFD->
hasAttr<OverloadableAttr>()) {
11341 if (
IsOverload(NewFD, cast<FunctionDecl>(OldDecl),
false)) {
11342 MayNeedOverloadableChecks =
true;
11343 Redeclaration =
false;
11351 return Redeclaration;
11370 !MD->
isStatic() && !isa<CXXConstructorDecl>(MD) &&
11374 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->
getAsFunction());
11375 if (!OldMD || !OldMD->
isStatic()) {
11397 if (Redeclaration) {
11403 return Redeclaration;
11410 dyn_cast<FunctionTemplateDecl>(OldDecl)) {
11411 auto *OldFD = OldTemplateDecl->getTemplatedDecl();
11414 assert(NewTemplateDecl &&
"Template/non-template mismatch");
11423 NewFD->
setAccess(OldTemplateDecl->getAccess());
11424 NewTemplateDecl->
setAccess(OldTemplateDecl->getAccess());
11429 if (IsMemberSpecialization &&
11432 assert(OldTemplateDecl->isMemberSpecialization());
11435 if (OldFD->isDeleted()) {
11437 assert(OldFD->getCanonicalDecl() == OldFD);
11439 OldFD->setDeletedAsWritten(
false);
11453 !NewFD->
getAttr<OverloadableAttr>()) {
11457 return ND->hasAttr<OverloadableAttr>();
11459 "Non-redecls shouldn't happen without overloadable present");
11462 const auto *FD = dyn_cast<FunctionDecl>(ND);
11463 return FD && !FD->
hasAttr<OverloadableAttr>();
11466 if (OtherUnmarkedIter !=
Previous.end()) {
11468 diag::err_attribute_overloadable_multiple_unmarked_overloads);
11469 Diag((*OtherUnmarkedIter)->getLocation(),
11470 diag::note_attribute_overloadable_prev_overload)
11487 dyn_cast<CXXDestructorDecl>(NewFD)) {
11500 return Redeclaration;
11503 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
11504 if (
auto *TD = Guide->getDescribedFunctionTemplate())
11510 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
11515 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
11516 if (!Method->isFunctionTemplateSpecialization() &&
11517 !Method->getDescribedFunctionTemplate() &&
11518 Method->isCanonicalDecl()) {
11525 diag::err_constrained_virtual_method);
11527 if (Method->isStatic())
11537 Diag(TRC->getBeginLoc(), diag::err_constrained_non_templated_function);
11547 return Redeclaration;
11554 return Redeclaration;
11574 Diag(NewFD->
getLocation(), diag::warn_return_value_udt) << NewFD << R;
11587 auto HasNoexcept = [&](
QualType T) ->
bool {
11592 T = RT->getPointeeType();
11593 else if (T->isAnyPointerType())
11594 T = T->getPointeeType();
11596 T = MPT->getPointeeType();
11598 if (FPT->isNothrow())
11604 bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
11605 for (
QualType T : FPT->param_types())
11606 AnyNoexcept |= HasNoexcept(T);
11609 diag::warn_cxx17_compat_exception_spec_in_signature)
11613 if (!Redeclaration &&
LangOpts.CUDA)
11616 return Redeclaration;
11629 ? diag::err_static_main : diag::warn_static_main)
11637 Diag(NoreturnLoc, diag::ext_noreturn_main);
11638 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
11650 << FD->
hasAttr<OpenCLKernelAttr>();
11661 assert(T->isFunctionType() &&
"function decl is not of function type");
11683 Diag(RTRange.
getBegin(), diag::note_main_change_return_type)
11705 if (isa<FunctionNoProtoType>(FT))
return;
11711 bool HasExtraParameters = (nparams > 3);
11723 HasExtraParameters =
false;
11725 if (HasExtraParameters) {
11738 for (
unsigned i = 0; i < nparams; ++i) {
11741 bool mismatch =
true;
11758 mismatch = !qs.
empty();
11787 if (T.isWindowsGNUEnvironment())
11792 if (T.isOSWindows() && T.getArch() == llvm::Triple::x86)
11800 assert(T->isFunctionType() &&
"function decl is not of function type");
11809 if (FD->
getName() !=
"DllMain")
11843 if (Init->isValueDependent()) {
11844 assert(Init->containsErrors() &&
11845 "Dependent code should only occur in error-recovery path.");
11848 const Expr *Culprit;
11849 if (Init->isConstantInitializer(
Context,
false, &Culprit))
11851 Diag(Culprit->
getExprLoc(), diag::err_init_element_not_constant)
11859 class SelfReferenceChecker
11865 bool isReferenceType;
11873 SelfReferenceChecker(
Sema &S,
Decl *OrigDecl) : Inherited(S.Context),
11874 S(S), OrigDecl(OrigDecl) {
11877 isReferenceType =
false;
11878 isInitList =
false;
11879 if (
ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
11880 isPODType = VD->getType().isPODType(S.
Context);
11882 isReferenceType = VD->getType()->isReferenceType();
11889 void CheckExpr(
Expr *E) {
11898 InitFieldIndex.push_back(0);
11899 for (
auto Child : InitList->
children()) {
11900 CheckExpr(cast<Expr>(Child));
11901 ++InitFieldIndex.back();
11903 InitFieldIndex.pop_back();
11908 bool CheckInitListMemberExpr(
MemberExpr *E,
bool CheckReference) {
11911 bool ReferenceField =
false;
11915 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
11918 Fields.push_back(FD);
11920 ReferenceField =
true;
11921 Base = ME->getBase()->IgnoreParenImpCasts();
11926 if (!DRE || DRE->
getDecl() != OrigDecl)
11930 if (CheckReference && !ReferenceField)
11935 for (
const FieldDecl *I : llvm::reverse(Fields))
11936 UsedFieldIndex.push_back(I->getFieldIndex());
11941 for (
auto UsedIter = UsedFieldIndex.begin(),
11942 UsedEnd = UsedFieldIndex.end(),
11943 OrigIter = InitFieldIndex.begin(),
11944 OrigEnd = InitFieldIndex.end();
11945 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
11946 if (*UsedIter < *OrigIter)
11948 if (*UsedIter > *OrigIter)
11953 HandleDeclRefExpr(DRE);
11960 void HandleValue(
Expr *E) {
11962 if (
DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
11963 HandleDeclRefExpr(DRE);
11968 Visit(CO->getCond());
11969 HandleValue(CO->getTrueExpr());
11970 HandleValue(CO->getFalseExpr());
11975 dyn_cast<BinaryConditionalOperator>(E)) {
11976 Visit(BCO->getCond());
11977 HandleValue(BCO->getFalseExpr());
11982 HandleValue(OVE->getSourceExpr());
11987 if (BO->getOpcode() == BO_Comma) {
11988 Visit(BO->getLHS());
11989 HandleValue(BO->getRHS());
11994 if (isa<MemberExpr>(E)) {
11996 if (CheckInitListMemberExpr(cast<MemberExpr>(E),
12004 if (!isa<FieldDecl>(ME->getMemberDecl()))
12006 Base = ME->getBase()->IgnoreParenImpCasts();
12009 HandleDeclRefExpr(DRE);
12019 if (isReferenceType)
12020 HandleDeclRefExpr(E);
12029 Inherited::VisitImplicitCastExpr(E);
12034 if (CheckInitListMemberExpr(E,
true ))
12044 bool Warn = (MD && !MD->
isStatic());
12047 if (!isa<FieldDecl>(ME->getMemberDecl()))
12049 Base = ME->getBase()->IgnoreParenImpCasts();
12054 HandleDeclRefExpr(DRE);
12066 if (isa<UnresolvedLookupExpr>(Callee))
12067 return Inherited::VisitCXXOperatorCallExpr(E);
12071 HandleValue(Arg->IgnoreParenImpCasts());
12088 Inherited::VisitUnaryOperator(E);
12096 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
12097 if (ILE->getNumInits() == 1)
12098 ArgExpr = ILE->getInit(0);
12100 if (ICE->getCastKind() == CK_NoOp)
12101 ArgExpr = ICE->getSubExpr();
12102 HandleValue(ArgExpr);
12105 Inherited::VisitCXXConstructExpr(E);
12111 HandleValue(E->
getArg(0));
12115 Inherited::VisitCallExpr(E);
12120 HandleValue(E->
getLHS());
12125 Inherited::VisitBinaryOperator(E);
12138 if (OrigDecl != ReferenceDecl)
return;
12140 if (isReferenceType) {
12141 diag = diag::warn_uninit_self_reference_in_reference_init;
12142 }
else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
12143 diag = diag::warn_static_self_reference_in_init;
12144 }
else if (isa<TranslationUnitDecl>(OrigDecl->
getDeclContext()) ||
12147 diag = diag::warn_uninit_self_reference_in_init;
12161 static void CheckSelfReference(
Sema &S,
Decl* OrigDecl,
Expr *E,
12165 if (isa<ParmVarDecl>(OrigDecl))
12174 if (ICE->getCastKind() == CK_LValueToRValue)
12175 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
12176 if (DRE->
getDecl() == OrigDecl)
12179 SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
12186 struct VarDeclOrName {
12192 return VN.VDecl ?
Diag << VN.VDecl :
Diag << VN.Name;
12202 bool IsInitCapture = !VDecl;
12204 "init captures are expected to be deduced prior to initialization");
12206 VarDeclOrName VN{VDecl, Name};
12209 assert(Deduced &&
"deduceVarTypeFromInitializer for non-deduced type");
12213 assert(VDecl &&
"no init for init capture deduction?");
12217 if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
12228 DeduceInits = Init;
12231 if (
auto *PL = dyn_cast_or_null<ParenListExpr>(Init))
12232 DeduceInits = PL->exprs();
12235 if (isa<DeducedTemplateSpecializationType>(Deduced)) {
12236 assert(VDecl &&
"non-auto type for init capture deduction?");
12247 if (
auto *IL = dyn_cast<InitListExpr>(Init))
12248 DeduceInits = IL->inits();
12252 if (DeduceInits.empty()) {
12255 Diag(Init->getBeginLoc(), IsInitCapture
12256 ? diag::err_init_capture_no_expression
12257 : diag::err_auto_var_init_no_expression)
12258 << VN <<
Type << Range;
12262 if (DeduceInits.size() > 1) {
12263 Diag(DeduceInits[1]->getBeginLoc(),
12264 IsInitCapture ? diag::err_init_capture_multiple_expressions
12265 : diag::err_auto_var_init_multiple_expressions)
12266 << VN <<
Type << Range;
12270 Expr *DeduceInit = DeduceInits[0];
12271 if (
DirectInit && isa<InitListExpr>(DeduceInit)) {
12272 Diag(Init->getBeginLoc(), IsInitCapture
12273 ? diag::err_init_capture_paren_braces
12274 : diag::err_auto_var_init_paren_braces)
12280 bool DefaultedAnyToId =
false;
12284 if (
Result.isInvalid()) {
12288 DefaultedAnyToId =
true;
12294 if (VDecl && isa<DecompositionDecl>(VDecl) &&
12298 Type.getQualifiers());
12302 if (!IsInitCapture)
12304 else if (isa<InitListExpr>(Init))
12305 Diag(Range.getBegin(),
12306 diag::err_init_capture_deduction_failure_from_init_list)
12312 Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
12327 Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;
12335 assert(!Init || !Init->containsErrors());
12369 if (
auto *EWC = dyn_cast<ExprWithCleanups>(Init))
12370 Init = EWC->getSubExpr();
12372 if (
auto *CE = dyn_cast<ConstantExpr>(Init))
12373 Init = CE->getSubExpr();
12375 QualType InitType = Init->getType();
12378 "shouldn't be called if type doesn't have a non-trivial C struct");
12379 if (
auto *ILE = dyn_cast<InitListExpr>(Init)) {
12380 for (
auto I : ILE->inits()) {
12381 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() &&
12382 !I->getType().hasNonTrivialToPrimitiveCopyCUnion())
12390 if (isa<ImplicitValueInitExpr>(Init)) {
12406bool shouldIgnoreForRecordTriviality(
const FieldDecl *FD) {
12412 return FD->
hasAttr<UnavailableAttr>();
12415struct DiagNonTrivalCUnionDefaultInitializeVisitor
12422 DiagNonTrivalCUnionDefaultInitializeVisitor(
12425 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
12428 const FieldDecl *FD,
bool InNonTrivialUnion) {
12431 InNonTrivialUnion);
12432 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
12436 bool InNonTrivialUnion) {
12437 if (InNonTrivialUnion)
12439 << 1 << 0 << QT << FD->
getName();
12443 if (InNonTrivialUnion)
12445 << 1 << 0 << QT << FD->
getName();
12451 if (OrigLoc.isValid()) {
12452 bool IsUnion =
false;
12453 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
12454 IsUnion = OrigRD->isUnion();
12455 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
12456 << 0 << OrigTy << IsUnion << UseContext;
12460 InNonTrivialUnion =
true;
12463 if (InNonTrivialUnion)
12468 if (!shouldIgnoreForRecordTriviality(FD))
12469 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
12482struct DiagNonTrivalCUnionDestructedTypeVisitor
12487 DiagNonTrivalCUnionDestructedTypeVisitor(
12490 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
12493 const FieldDecl *FD,
bool InNonTrivialUnion) {
12496 InNonTrivialUnion);
12497 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
12501 bool InNonTrivialUnion) {
12502 if (InNonTrivialUnion)
12504 << 1 << 1 << QT << FD->
getName();
12508 if (InNonTrivialUnion)
12510 << 1 << 1 << QT << FD->
getName();
12516 if (OrigLoc.isValid()) {
12517 bool IsUnion =
false;
12518 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
12519 IsUnion = OrigRD->isUnion();
12520 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
12521 << 1 << OrigTy << IsUnion << UseContext;
12525 InNonTrivialUnion =
true;
12528 if (InNonTrivialUnion)
12533 if (!shouldIgnoreForRecordTriviality(FD))
12534 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
12539 bool InNonTrivialUnion) {}
12549struct DiagNonTrivalCUnionCopyVisitor
12556 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
12559 const FieldDecl *FD,
bool InNonTrivialUnion) {
12562 InNonTrivialUnion);
12563 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
12567 bool InNonTrivialUnion) {
12568 if (InNonTrivialUnion)
12570 << 1 << 2 << QT << FD->
getName();
12574 if (InNonTrivialUnion)
12576 << 1 << 2 << QT << FD->
getName();
12582 if (OrigLoc.isValid()) {
12583 bool IsUnion =
false;
12584 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
12585 IsUnion = OrigRD->isUnion();
12586 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
12587 << 2 << OrigTy << IsUnion << UseContext;
12591 InNonTrivialUnion =
true;
12594 if (InNonTrivialUnion)
12599 if (!shouldIgnoreForRecordTriviality(FD))
12600 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
12604 const FieldDecl *FD,
bool InNonTrivialUnion) {}
12607 bool InNonTrivialUnion) {}
12621 unsigned NonTrivialKind) {
12625 "shouldn't be called if type doesn't have a non-trivial C union");
12629 DiagNonTrivalCUnionDefaultInitializeVisitor(QT, Loc, UseContext, *
this)
12630 .visit(QT,
nullptr,
false);
12633 DiagNonTrivalCUnionDestructedTypeVisitor(QT, Loc, UseContext, *
this)
12634 .visit(QT,
nullptr,
false);
12636 DiagNonTrivalCUnionCopyVisitor(QT, Loc, UseContext, *
this)
12637 .visit(QT,
nullptr,
false);
12651 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
12653 Diag(Method->getLocation(), diag::err_member_function_initialization)
12654 << Method->getDeclName() << Init->getSourceRange();
12655 Method->setInvalidDecl();
12659 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
12661 assert(!isa<FieldDecl>(RealDecl) &&
"field init shouldn't get here");
12693 Diag(VDecl->
getLocation(), diag::err_attribute_dllimport_data_definition);
12711 BaseDeclType = Array->getElementType();
12713 diag::err_typecheck_decl_incomplete_type)) {
12720 diag::err_abstract_type_in_decl,
12729 if (Def != VDecl &&
12749 Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
12752 diag::note_previous_initializer)
12775 if (VDecl->
hasAttr<LoaderUninitializedAttr>()) {
12776 Diag(VDecl->
getLocation(), diag::err_loader_uninitialized_cant_init);
12790 if (
Result.isInvalid()) {
12798 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
12810 for (
size_t Idx = 0; Idx < Args.size(); ++Idx) {
12812 Args[Idx], VDecl,
true,
12813 [
this, Entity, Kind](
Expr *E) {
12815 return Init.Failed() ?
ExprError() : E;
12819 }
else if (Res.
get() != Args[Idx]) {
12820 Args[Idx] = Res.
get();
12830 if (
Result.isInvalid()) {
12850 CheckSelfReference(*
this, RealDecl, Init,
DirectInit);
12862 if (VDecl->
hasAttr<BlocksAttr>())
12876 Init->getBeginLoc()))
12877 FSI->markSafeWeakUse(Init);
12894 if (
Result.isInvalid()) {
12927 isa<InitListExpr>(Init)) {
12928 const Expr *Culprit;
12929 if (!Init->isConstantInitializer(
Context,
false, &Culprit)) {
12931 diag::ext_aggregate_init_not_constant)
12936 if (
auto *E = dyn_cast<ExprWithCleanups>(Init))
12937 if (
auto *BE = dyn_cast<BlockExpr>(E->getSubExpr()->
IgnoreParens()))
12939 BE->getBlockDecl()->setCanAvoidCopyToHeap();
12974 << Init->getSourceRange();
12985 else if (Init->isValueDependent())
12987 else if (Init->isIntegerConstantExpr(
Context, &Loc))
12989 else if (Init->getType()->isScopedEnumeralType() &&
12990 Init->isCXX11ConstantExpr(
Context))
12992 else if (Init->isEvaluatable(
Context)) {
12995 Diag(Loc, diag::ext_in_class_initializer_non_constant)
12996 << Init->getSourceRange();
13000 Diag(Loc, diag::err_in_class_initializer_non_constant)
13001 << Init->getSourceRange();
13011 diag::ext_in_class_initializer_float_type_cxx11)
13012 << DclT << Init->getSourceRange();
13014 diag::note_in_class_initializer_float_type_cxx11)
13017 Diag(VDecl->
getLocation(), diag::ext_in_class_initializer_float_type)
13018 << DclT << Init->getSourceRange();
13020 if (!Init->isValueDependent() && !Init->isEvaluatable(
Context)) {
13021 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
13022 << Init->getSourceRange();
13029 Diag(VDecl->
getLocation(), diag::err_in_class_initializer_literal_type)
13030 << DclT << Init->getSourceRange()
13036 << DclT << Init->getSourceRange();
13067 QualType InitType = Init->getType();
13068 if (!InitType.
isNull() &&
13087 if (CXXDirectInit) {
13088 assert(
DirectInit &&
"Call-style initializer must be direct init.");
13098 DeclsToCheckForDeferredDiags.insert(VDecl);
13111 VarDecl *VD = dyn_cast<VarDecl>(D);
13115 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
13116 for (
auto *BD : DD->bindings())
13117 BD->setInvalidDecl();
13131 diag::err_typecheck_decl_incomplete_type)) {
13138 diag::err_abstract_type_in_decl,
13153 if (
VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
13157 if (isa<DecompositionDecl>(RealDecl)) {
13158 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
13159 Var->setInvalidDecl();
13173 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
13174 !Var->isThisDeclarationADemotedDefinition()) {
13175 if (Var->isStaticDataMember()) {
13180 Diag(Var->getLocation(),
13181 diag::err_constexpr_static_mem_var_requires_init)
13183 Var->setInvalidDecl();
13187 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
13188 Var->setInvalidDecl();
13195 if (!Var->isInvalidDecl() &&
13197 Var->getStorageClass() !=
SC_Extern && !Var->getInit()) {
13198 bool HasConstExprDefaultConstructor =
false;
13199 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
13200 for (
auto *Ctor : RD->ctors()) {
13201 if (Ctor->isConstexpr() && Ctor->getNumParams() == 0 &&
13202 Ctor->getMethodQualifiers().getAddressSpace() ==
13204 HasConstExprDefaultConstructor =
true;
13208 if (!HasConstExprDefaultConstructor) {
13209 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
13210 Var->setInvalidDecl();
13215 if (!Var->isInvalidDecl() && RealDecl->
hasAttr<LoaderUninitializedAttr>()) {
13216 if (Var->getStorageClass() ==
SC_Extern) {
13217 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
13219 Var->setInvalidDecl();
13223 diag::err_typecheck_decl_incomplete_type)) {
13224 Var->setInvalidDecl();
13227 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
13228 if (!RD->hasTrivialDefaultConstructor()) {
13229 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
13230 Var->setInvalidDecl();
13240 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
13247 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
13263 !Var->hasLinkage() && !Var->isInvalidDecl() &&
13265 diag::err_typecheck_decl_incomplete_type))
13266 Var->setInvalidDecl();
13271 diag::err_abstract_type_in_decl,
13273 Var->setInvalidDecl();
13276 Diag(Var->getLocation(), diag::warn_private_extern);
13277 Diag(Var->getLocation(), diag::note_private_extern);
13292 if (!Var->isInvalidDecl()) {
13296 Var->getLocation(), ArrayT->getElementType(),
13297 diag::err_array_incomplete_or_sizeless_type))
13298 Var->setInvalidDecl();
13299 }
else if (Var->getStorageClass() ==
SC_Static) {
13309 if (Var->isFirstDecl())
13311 diag::ext_typecheck_decl_incomplete_type);
13316 if (!Var->isInvalidDecl())
13324 Diag(Var->getLocation(),
13325 diag::err_typecheck_incomplete_array_needs_initializer);
13326 Var->setInvalidDecl();
13333 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
13334 << Var <<
SourceRange(Var->getLocation(), Var->getLocation());
13343 if (Var->isInvalidDecl())
13346 if (!Var->hasAttr<AliasAttr>()) {
13349 diag::err_typecheck_decl_incomplete_type)) {
13350 Var->setInvalidDecl();
13359 diag::err_abstract_type_in_decl,
13361 Var->setInvalidDecl();
13382 if (!CXXRecord->isPOD())
13416 }
else if (Init.isInvalid()) {
13434 VarDecl *VD = dyn_cast<VarDecl>(D);
13493 const char *PrevSpec;
13559 !isa<VarTemplatePartialSpecializationDecl>(var) &&
13561 !
getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
13569 Diag(var->
getLocation(), diag::warn_missing_variable_declarations) << var;
13577 const Expr *CacheCulprit =
nullptr;
13578 auto checkConstInit = [&]()
mutable {
13579 if (!CacheHasConstInit)
13582 return *CacheHasConstInit;
13594 if (!checkConstInit()) {
13609 isa<InitListExpr>(var->
getInit())) {
13611 unsigned NumInits = ILE->getNumInits();
13613 for (
unsigned I = 0; I < NumInits; ++I) {
13614 const auto *Init = ILE->getInit(I);
13617 const auto *SL = dyn_cast<StringLiteral>(Init->IgnoreImpCasts());
13621 unsigned NumConcat = SL->getNumConcatenated();
13625 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {
13626 bool OnlyOneMissingComma =
true;
13627 for (
unsigned J = I + 1; J < NumInits; ++J) {
13628 const auto *Init = ILE->getInit(J);
13631 const auto *SLJ = dyn_cast<StringLiteral>(Init->IgnoreImpCasts());
13632 if (!SLJ || SLJ->getNumConcatenated() > 1) {
13633 OnlyOneMissingComma =
false;
13638 if (OnlyOneMissingComma) {
13640 for (
unsigned i = 0; i < NumConcat - 1; ++i)
13644 Diag(SL->getStrTokenLoc(1),
13645 diag::warn_concatenated_literal_array_init)
13647 Diag(SL->getBeginLoc(),
13648 diag::note_concatenated_string_literal_silence);
13659 if (var->
hasAttr<BlocksAttr>())
13666 bool HasConstInit =
true;
13670 !Init->isValueDependent() &&
13684 HasConstInit = checkConstInit();
13688 if (HasConstInit) {
13691 }
else if (CacheCulprit) {
13692 Notes.emplace_back(CacheCulprit->
getExprLoc(),
13693 PDiag(diag::note_invalid_subexpr_in_const_expr));
13701 if (HasConstInit) {
13707 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
13708 diag::note_invalid_subexpr_in_const_expr) {
13709 DiagLoc = Notes[0].first;
13712 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
13713 << var << Init->getSourceRange();
13714 for (
unsigned I = 0,
N = Notes.size(); I !=
N; ++I)
13715 Diag(Notes[I].first, Notes[I].second);
13716 }
else if (GlobalStorage && var->
hasAttr<ConstInitAttr>()) {
13719 << Init->getSourceRange();
13722 for (
auto &it : Notes)
13723 Diag(it.first, it.second);
13724 }
else if (IsGlobal &&
13735 if (!checkConstInit())
13737 << Init->getSourceRange();
13754 }
else if (var->
hasInit() && HasConstInit) {
13761 if (
const SectionAttr *SA = var->
getAttr<SectionAttr>()) {
13765 }
else if (Stack->CurrentValue) {
13767 auto SectionName = Stack->CurrentValue->getString();
13768 var->
addAttr(SectionAttr::CreateImplicit(
13769 Context, SectionName, Stack->CurrentPragmaLocation,
13794 if (!type->isDependentType())
13804 if (
auto *DD = dyn_cast<DecompositionDecl>(var))
13817 !FD->
hasAttr<DLLExportStaticLocalAttr>() &&
13818 !FD->
hasAttr<DLLImportStaticLocalAttr>()) {
13828 NewAttr->setInherited(
true);
13830 }
else if (
Attr *A = FD->
getAttr<DLLExportStaticLocalAttr>()) {
13831 auto *NewAttr = DLLExportAttr::CreateImplicit(
getASTContext(), *A);
13832 NewAttr->setInherited(
true);
13837 if (!FD->
hasAttr<DLLExportAttr>())
13840 }
else if (
Attr *A = FD->
getAttr<DLLImportStaticLocalAttr>()) {
13841 auto *NewAttr = DLLImportAttr::CreateImplicit(
getASTContext(), *A);
13842 NewAttr->setInherited(
true);
13853 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
13861 VD->
addAttr(PragmaClangBSSSectionAttr::CreateImplicit(
13866 VD->
addAttr(PragmaClangDataSectionAttr::CreateImplicit(
13871 VD->
addAttr(PragmaClangRodataSectionAttr::CreateImplicit(
13876 VD->
addAttr(PragmaClangRelroSectionAttr::CreateImplicit(
13882 if (
auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
13883 for (
auto *BD : DD->bindings()) {
13921 if (
const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
13928 bool IsClassTemplateMember =
13930 Context->getDescribedClassTemplate();
13933 IsClassTemplateMember
13934 ? diag::warn_attribute_dllimport_static_field_definition
13935 : diag::err_attribute_dllimport_static_field_definition);
13936 Diag(IA->getLocation(), diag::note_attribute);
13937 if (!IsClassTemplateMember)
13965 if (RetainAttr *
Attr = VD->
getAttr<RetainAttr>()) {
13980 if (VD->
isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
13985 if (!VD->
hasAttr<TypeTagForDatatypeAttr>() ||
13989 for (
const auto *I : ThisDecl->
specific_attrs<TypeTagForDatatypeAttr>()) {
13991 if (!MagicValueExpr) {
13996 Diag(I->getRange().getBegin(),
13997 diag::err_type_tag_for_datatype_not_ice)
14001 if (MagicValueInt->getActiveBits() > 64) {
14002 Diag(I->getRange().getBegin(),
14003 diag::err_type_tag_for_datatype_too_large)
14007 uint64_t MagicValue = MagicValueInt->getZExtValue();
14010 I->getMatchingCType(),
14011 I->getLayoutCompatible(),
14012 I->getMustBeNull());
14017 auto *VD = dyn_cast<VarDecl>(DD);
14018 return VD && !VD->getType()->hasAutoForTrailingReturnType();
14030 bool DiagnosedMultipleDecomps =
false;
14032 bool DiagnosedNonDeducedAuto =
false;
14034 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14035 if (
Decl *D = Group[i]) {
14038 if (
auto *DD = dyn_cast<DeclaratorDecl>(D)) {
14039 if (!FirstDeclaratorInGroup)
14040 FirstDeclaratorInGroup = DD;
14041 if (!FirstDecompDeclaratorInGroup)
14042 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(D);
14045 FirstNonDeducedAutoInGroup = DD;
14047 if (FirstDeclaratorInGroup != DD) {
14050 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
14052 diag::err_decomp_decl_not_alone)
14054 << DD->getSourceRange();
14055 DiagnosedMultipleDecomps =
true;
14061 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
14063 diag::err_auto_non_deduced_not_alone)
14064 << FirstNonDeducedAutoInGroup->
getType()
14067 << DD->getSourceRange();
14068 DiagnosedNonDeducedAuto =
true;
14073 Decls.push_back(D);
14080 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
14096 if (Group.size() > 1) {
14098 VarDecl *DeducedDecl =
nullptr;
14099 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14100 VarDecl *D = dyn_cast<VarDecl>(Group[i]);
14110 auto *AT = dyn_cast<AutoType>(DT);
14112 diag::err_auto_different_deductions)
14113 << (AT ? (
unsigned)AT->getKeyword() : 3) << Deduced
14138 if (Group.empty() || !Group[0])
14142 Group[0]->getLocation()) &&
14144 Group[0]->getLocation()))
14147 if (Group.size() >= 2) {
14155 Decl *MaybeTagDecl = Group[0];
14156 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
14157 Group = Group.slice(1);
14222 : diag::warn_deprecated_register)
14230 diag::err_invalid_storage_class_in_func_decl);
14242 << 0 <<
static_cast<int>(D.
getDeclSpec().getConstexprSpecifier());
14263 PrevDecl =
nullptr;
14264 }
else if (S->isDeclScope(PrevDecl)) {
14286 assert(S->isFunctionPrototypeScope());
14287 assert(S->getFunctionPrototypeDepth() >= 1);
14289 S->getNextFunctionPrototypeIndex());
14303 if (New->
hasAttr<BlocksAttr>()) {
14324 Param->setImplicit();
14337 Diag(
Parameter->getLocation(), diag::warn_unused_parameter)
14345 if (
LangOpts.NumLargeByValueCopy == 0)
14352 if (Size >
LangOpts.NumLargeByValueCopy)
14360 if (T->isDependentType() || !T.isPODType(
Context))
14363 if (Size >
LangOpts.NumLargeByValueCopy)
14376 T->isObjCLifetimeType()) {
14383 if (T->isArrayType()) {
14384 if (!T.isConstQualified()) {
14388 NameLoc, diag::err_arc_array_param_no_ownership, T,
false));
14390 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
14395 lifetime = T->getObjCARCImplicitLifetime();
14402 TSInfo, SC,
nullptr);
14409 LSI->LocalPacks.push_back(New);
14426 if (T->isObjCObjectType()) {
14430 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
14445 Diag(NameLoc, diag::err_arg_with_address_space);
14473 for (
int i = FTI.
NumParams; i != 0; ) {
14478 llvm::raw_svector_ostream(Code)
14489 const char* PrevSpec;
14523 ParentScope, D, TemplateParameterLists, Bases);
14529 if (!Bases.empty())
14551 if (isa<CXXMethodDecl>(FD))
14557 if (II->isStr(
"main") || II->isStr(
"efi_main"))
14573 if (FD->
hasAttr<OpenCLKernelAttr>())
14589 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
14592 PossiblePrototype = Prev;
14634 Definition->getDescribedFunctionTemplate() ||
14635 Definition->getNumTemplateParameterLists())) {
14638 if (
auto *TD =
Definition->getDescribedFunctionTemplate())
14651 Diag(
Definition->getLocation(), diag::note_previous_definition);
14661 LSI->
Lambda = LambdaClass;
14679 for (
const auto &
C : LambdaClass->
captures()) {
14680 if (
C.capturesVariable()) {
14684 const bool ByRef =
C.getCaptureKind() ==
LCK_ByRef;
14686 true,
C.getLocation(),
14687 C.isPackExpansion()
14689 I->getType(),
false);
14691 }
else if (
C.capturesThis()) {
14716 FD = FunTmpl->getTemplatedDecl();
14728 if (
const auto *
Attr = FD->
getAttr<AliasAttr>()) {
14733 if (
const auto *
Attr = FD->
getAttr<IFuncAttr>()) {
14739 if (
auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
14741 Ctor->isDefaultConstructor() &&
14776 "There should be an active template instantiation on the stack "
14777 "when instantiating a generic lambda!");
14799 diag::err_func_def_incomplete_result))
14814 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
14817 assert(!isa<ParmVarDecl>(NonParmDecl) &&
14818 "parameters should not be in newly created FD yet");
14821 if (NonParmDecl->getDeclName())
14826 if (
auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
14827 for (
auto *EI : ED->enumerators())
14835 Param->setOwningFunction(FD);
14838 if (Param->getIdentifier() && FnBodyScope) {
14852 assert(!FD->
hasAttr<DLLExportAttr>());
14853 Diag(FD->
getLocation(), diag::err_attribute_dllimport_function_definition);
14883 for (
unsigned I = 0, E =
Scope->Returns.size(); I != E; ++I) {
14884 if (
const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
14885 if (!NRVOCandidate->isNRVOVariable())
14904 Outer.Fun.hasTrailingReturnType()) {
14922 if (FD->isConstexpr())
14927 if (FD->getReturnType()->getContainedDeducedType())
14937 FD->setHasSkippedBody();
14959 bool IsLambda =
false;
14963 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;
14965 auto IsOrNestedInEscapingBlock = [&](
const BlockDecl *BD) {
14966 if (EscapeInfo.count(BD))
14967 return EscapeInfo[BD];
14979 return EscapeInfo[BD] = R;
14984 for (
const std::pair<SourceLocation, const BlockDecl *> &
P :
14986 if (IsOrNestedInEscapingBlock(
P.second))
14987 S.
Diag(
P.first, diag::warn_implicitly_retains_self)
14992 bool IsInstantiation) {
15027 Expr *Dummy =
nullptr;
15038 if (LSI->HasImplicitReturnType) {
15045 LSI->ReturnType.isNull() ?
Context.
VoidTy : LSI->ReturnType;
15050 Proto->getExtProtoInfo()));
15077 dyn_cast<CXXDestructorDecl>(FD))
15097 if (PossiblePrototype) {
15101 TypeLoc TL = TI->getTypeLoc();
15104 diag::note_declaration_not_a_prototype)
15107 FTL.getRParenLoc(),
"void")
15114 std::pair<FileID, unsigned> LocInfo =
SM.getDecomposedLoc(Loc);
15115 if (LocInfo.first.isInvalid())
15119 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
15123 if (LocInfo.second > Buffer.size())
15126 const char *LexStart = Buffer.data() + LocInfo.second;
15127 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second);
15129 return StartTok.consume_front(
"const") &&
15131 StartTok.startswith(
"/*") || StartTok.startswith(
"//"));
15134 auto findBeginLoc = [&]() {
15150 diag::note_static_for_internal_linkage)
15201 if (PossiblePrototype)
15203 diag::warn_non_prototype_changes_behavior)
15210 if (
const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
15211 if (!CmpndBody->body_empty())
15212 Diag(CmpndBody->body_front()->getBeginLoc(),
15213 diag::warn_dispatch_body_ignored);
15215 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
15241 "Function parsing confused");
15242 }
else if (
ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
15254 << MD->getSelector().getAsString();
15259 bool isDesignated =
15260 MD->isDesignatedInitializerForTheInterface(&InitMethod);
15261 assert(isDesignated && InitMethod);
15262 (void)isDesignated;
15265 auto IFace = MD->getClassInterface();
15268 auto SuperD = IFace->getSuperClass();
15278 diag::warn_objc_designated_init_missing_super_call);
15280 diag::note_objc_designated_init_marked_here);
15288 diag::warn_objc_secondary_init_missing_init_call);
15304 "This should only be set for ObjC methods, which should have been "
15305 "handled in the block above.");
15312 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
15320 if (!Destructor->getParent()->isDependentType())
15324 Destructor->getParent());
15337 ActivePolicy = &WP;
15344 if (FD && FD->
hasAttr<NakedAttr>()) {
15348 bool RegisterVariables =
false;
15349 if (
auto *DS = dyn_cast<DeclStmt>(S)) {
15350 for (
const auto *
Decl : DS->decls()) {
15351 if (
const auto *Var = dyn_cast<VarDecl>(
Decl)) {
15352 RegisterVariables =
15353 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
15354 if (!RegisterVariables)
15359 if (RegisterVariables)
15361 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
15362 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
15363 Diag(FD->
getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
15372 "Leftover temporaries in function");
15373 assert(!Cleanup.exprNeedsCleanups() &&
15374 "Unaccounted cleanups in function");
15376 "Leftover expressions for odr-use checking");
15382 if (!IsInstantiation)
15399 DeclsToCheckForDeferredDiags.insert(FD);
15414 D = TD->getTemplatedDecl();
15417 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
15418 if (Method->isStatic())
15428 "Implicit function declarations aren't allowed in this language mode");
15435 Scope *BlockScope = S;
15439 Scope *ContextScope = BlockScope;
15441 ContextScope = ContextScope->
getParent();
15457 if (!isa<FunctionDecl>(ExternCPrev) ||
15459 cast<FunctionDecl>(ExternCPrev)->getType(),
15461 Diag(Loc, diag::ext_use_out_of_scope_declaration)
15464 return ExternCPrev;
15470 if (II.
getName().startswith(
"__builtin_"))
15471 diag_id = diag::warn_builtin_unknown;
15474 diag_id = diag::ext_implicit_function_decl_c99;
15476 diag_id = diag::warn_implicit_function_decl;
15484 if (S && !ExternCPrev &&
15491 Diag(Loc, diag_id) << &II;
15507 return ExternCPrev;
15517 assert(!Error &&
"Error setting up implicit decl!");
15566 bool IsNothrow =
false;
15575 if (!IsNothrow && !FD->
hasAttr<ReturnsNonNullAttr>())
15592 if (!FD->
hasAttr<AllocSizeAttr>()) {
15593 FD->
addAttr(AllocSizeAttr::CreateImplicit(
15604 if (AlignmentParam && !FD->
hasAttr<AllocAlignAttr>()) {
15605 FD->
addAttr(AllocAlignAttr::CreateImplicit(
15638 unsigned FormatIdx;
15641 if (!FD->
hasAttr<FormatAttr>()) {
15642 const char *fmt =
"printf";
15644 if (FormatIdx < NumParams &&
15650 HasVAListArg ? 0 : FormatIdx+2,
15656 if (!FD->
hasAttr<FormatAttr>())
15660 HasVAListArg ? 0 : FormatIdx+2,
15666 if (!FD->
hasAttr<CallbackAttr>() &&
15668 FD->
addAttr(CallbackAttr::CreateImplicit(
15682 if ((Trip.isGNUEnvironment() || Trip.isOSMSVCRT()) &&
15684 switch (BuiltinID) {
15685 case Builtin::BI__builtin_fma:
15686 case Builtin::BI__builtin_fmaf:
15687 case Builtin::BI__builtin_fmal:
15688 case Builtin::BIfma:
15689 case Builtin::BIfmaf:
15690 case Builtin::BIfmal:
15699 !FD->
hasAttr<ReturnsTwiceAttr>())
15709 !FD->
hasAttr<CUDADeviceAttr>() && !FD->
hasAttr<CUDAHostAttr>()) {
15721 switch (BuiltinID) {
15722 case Builtin::BImemalign:
15723 case Builtin::BIaligned_alloc:
15724 if (!FD->
hasAttr<AllocAlignAttr>())
15733 switch (BuiltinID) {
15734 case Builtin::BIcalloc:
15735 FD->
addAttr(AllocSizeAttr::CreateImplicit(
15738 case Builtin::BImemalign:
15739 case Builtin::BIaligned_alloc:
15740 case Builtin::BIrealloc:
15744 case Builtin::BImalloc:
15761 if (!FPT || FPT->getExceptionSpecType() ==
EST_None)
15778 if (Name->isStr(
"asprintf") || Name->isStr(
"vasprintf")) {
15781 if (!FD->
hasAttr<FormatAttr>())
15784 Name->isStr(
"vasprintf") ? 0 : 3,
15788 if (Name->isStr(
"__CFStringMakeConstantString")) {
15791 if (!FD->
hasAttr<FormatArgAttr>())
15799 assert(D.
getIdentifier() &&
"Wrong callback for declspec without declarator");
15800 assert(!T.isNull() &&
"GetTypeForDeclarator() returned null type");
15803 assert(D.
isInvalidType() &&
"no declarator info for valid type");
15858 if (T->isDependentType())
15864 if (BT->isInteger())
15867 if (T->isBitIntType())
15870 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
15876 QualType EnumUnderlyingTy,
bool IsFixed,
15878 if (IsScoped != Prev->
isScoped()) {
15879 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
15885 if (IsFixed && Prev->
isFixed()) {
15891 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
15897 }
else if (IsFixed != Prev->
isFixed()) {
15898 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
15917 default: llvm_unreachable(
"Invalid tag kind for redecl diagnostic!");
15932 if (isa<TypedefDecl>(PrevDecl))
15934 else if (isa<TypeAliasDecl>(PrevDecl))
15936 else if (isa<ClassTemplateDecl>(PrevDecl))
15938 else if (isa<TypeAliasTemplateDecl>(PrevDecl))
15940 else if (isa<TemplateTemplateParmDecl>(PrevDecl))
15952 llvm_unreachable(
"invalid TTK");
15977 if (OldTag != NewTag &&
15995 if (IsIgnoredLoc(NewTagLoc))
15998 auto IsIgnored = [&](
const TagDecl *Tag) {
15999 return IsIgnoredLoc(Tag->getLocation());
16010 isTemplate = Record->getDescribedClassTemplate();
16013 if (OldTag != NewTag) {
16016 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
16024 if (isDefinition) {
16032 bool previousMismatch =
false;
16034 if (I->getTagKind() != NewTag) {
16039 if (!previousMismatch) {
16040 previousMismatch =
true;
16041 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
16045 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
16058 if (PrevDef && IsIgnored(PrevDef))
16062 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
16069 Diag(NewTagLoc, diag::note_struct_class_suggestion)
16099 if (!Namespace || Namespace->isAnonymousNamespace())
16102 Namespaces.push_back(II);
16105 if (Lookup == Namespace)
16112 llvm::raw_svector_ostream OS(Insertion);
16115 std::reverse(Namespaces.begin(), Namespaces.end());
16116 for (
auto *II : Namespaces)
16117 OS << II->getName() <<
"::";
16130 if (OldDC->
Equals(NewDC))
16158 bool &OwnedDecl,
bool &IsDependent,
16160 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
16161 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
16166 "Nameless record must be a definition!");
16167 assert(TemplateParameterLists.size() == 0 || TUK !=
TUK_Reference);
16171 bool ScopedEnum = ScopedEnumKWLoc.
isValid();
16174 bool isMemberSpecialization =
false;
16180 if (TemplateParameterLists.size() > 0 ||
16184 KWLoc, NameLoc, SS,
nullptr, TemplateParameterLists,
16187 Diag(KWLoc, diag::err_enum_template);
16191 if (TemplateParams->size() > 0) {
16200 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
16201 AS, ModulePrivateLoc,
16203 TemplateParameterLists.data(), SkipBody);
16207 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
16209 isMemberSpecialization =
true;
16213 if (!TemplateParameterLists.empty() && isMemberSpecialization &&
16221 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
16222 bool IsFixed = !UnderlyingType.
isUnset() || ScopedEnum;
16225 if (UnderlyingType.
isInvalid() || (!UnderlyingType.
get() && ScopedEnum)) {
16229 }
else if (UnderlyingType.
get()) {
16234 EnumUnderlying = TI;
16256 bool isStdBadAlloc =
false;
16257 bool isStdAlignValT =
false;
16266 auto createTagFromNewDecl = [&]() ->
TagDecl * {
16276 ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
16280 if (EnumUnderlying) {
16296 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
16322 goto CreateNewDecl;
16330 IsDependent =
true;
16359 if (
Previous.wasNotFoundInCurrentInstantiation() &&
16361 IsDependent =
true;
16366 Diag(NameLoc, diag::err_not_tag_in_scope)
16367 << Kind << Name << DC << SS.
getRange();
16370 goto CreateNewDecl;
16418 bool FriendSawTagOutsideEnclosingNamespace =
false;
16425 FriendSawTagOutsideEnclosingNamespace =
true;
16434 if (
Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
16436 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
16450 while (isa<RecordDecl, EnumDecl, ObjCContainerDecl>(SearchDC))
16456 while (isa<ObjCContainerDecl>(SearchDC))
16462 while (isa<ObjCContainerDecl>(SearchDC))
16467 Previous.getFoundDecl()->isTemplateParameter()) {
16476 if (Name->isStr(
"bad_alloc")) {
16478 isStdBadAlloc =
true;
16485 }
else if (Name->isStr(
"align_val_t")) {
16486 isStdAlignValT =
true;
16498 if (
Invalid)
goto CreateNewDecl;
16579 TagDecl *Tag = TT->getDecl();
16580 if (Tag->getDeclName() == Name &&
16581 Tag->getDeclContext()->getRedeclContext()
16582 ->Equals(TD->getDeclContext()->getRedeclContext())) {
16595 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
16596 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
16598 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
16600 *
this, OldTag->getDeclContext(), SearchDC))) {
16601 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
16602 Diag(Shadow->getTargetDecl()->getLocation(),
16603 diag::note_using_decl_target);
16604 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
16608 goto CreateNewDecl;
16612 if (
TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
16618 SS.
isNotEmpty() || isMemberSpecialization)) {
16624 bool SafeToContinue
16625 = (PrevTagDecl->getTagKind() !=
TTK_Enum &&
16627 if (SafeToContinue)
16628 Diag(KWLoc, diag::err_use_with_wrong_tag)
16631 PrevTagDecl->getKindName());
16633 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
16634 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
16636 if (SafeToContinue)
16637 Kind = PrevTagDecl->getTagKind();
16649 return PrevTagDecl;
16653 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
16654 else if (
const Type *T = EnumUnderlying.dyn_cast<
const Type*>())
16655 EnumUnderlyingTy =
QualType(T, 0);
16661 ScopedEnum, EnumUnderlyingTy,
16662 IsFixed, PrevEnum))
16671 S->isDeclScope(PrevDecl)) {
16672 Diag(NameLoc, diag::ext_member_redeclared);
16673 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
16680 if (!Attrs.
empty()) {
16684 (PrevTagDecl->getFriendObjectKind() ==
16697 return PrevTagDecl;
16702 return PrevTagDecl;
16708 if (
NamedDecl *Def = PrevTagDecl->getDefinition()) {
16712 bool IsExplicitSpecializationAfterInstantiation =
false;
16713 if (isMemberSpecialization) {
16715 IsExplicitSpecializationAfterInstantiation =
16716 RD->getTemplateSpecializationKind() !=
16718 else if (
EnumDecl *ED = dyn_cast<EnumDecl>(Def))
16719 IsExplicitSpecializationAfterInstantiation =
16720 ED->getTemplateSpecializationKind() !=
16740 SkipBody->
New = createTagFromNewDecl();
16750 }
else if (!IsExplicitSpecializationAfterInstantiation) {
16754 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
16756 Diag(NameLoc, diag::err_redefinition) << Name;
16758 NameLoc.
isValid() ? NameLoc : KWLoc);
16770 if (TD->isBeingDefined()) {
16771 Diag(NameLoc, diag::err_nested_redefinition) << Name;
16772 Diag(PrevTagDecl->getLocation(),
16773 diag::note_previous_definition);
16788 SearchDC = PrevTagDecl->getDeclContext();
16816 Diag(NameLoc, diag::err_tag_reference_non_tag) << PrevDecl << NTK
16823 SS.
isNotEmpty() || isMemberSpecialization)) {
16829 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
16835 }
else if (
TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
16837 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
16838 Diag(NameLoc, diag::err_tag_definition_of_typedef)
16839 << Name << Kind << TND->getUnderlyingType();
16847 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
16879 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
16880 ScopedEnumUsesClassTag, IsFixed);
16888 if (IsFixed && cast<EnumDecl>(New)->isFixed()) {
16892 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->
getDefinition())) {
16893 Diag(Loc, diag::ext_forward_ref_enum_def)
16897 unsigned DiagID = diag::ext_forward_ref_enum;
16899 DiagID = diag::ext_ms_forward_ref_enum;
16901 DiagID = diag::err_forward_ref_enum;
16906 if (EnumUnderlying) {
16916 assert(ED->
isComplete() &&
"enum with type should be complete");
16926 cast_or_null<CXXRecordDecl>(PrevDecl));
16932 cast_or_null<RecordDecl>(PrevDecl));
16958 isMemberSpecialization))
16962 if (TemplateParameterLists.size() > 0) {
16970 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
16986 if (ModulePrivateLoc.
isValid()) {
16987 if (isMemberSpecialization)
17012 Diag(Loc, diag::err_type_defined_in_param_type)
17016 }
else if (!PrevDecl) {
17077 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(New))
17092 if (
auto RD = dyn_cast<RecordDecl>(New))
17095 }
else if (SkipBody && SkipBody->
ShouldSkip) {
17127 "The next DeclContext should be lexically contained in the current one.");
17133 bool IsFinalSpelledSealed,
17141 if (!Record->getIdentifier())
17145 Record->markAbstract();
17148 Record->addAttr(FinalAttr::Create(
17150 static_cast<FinalAttr::Spelling
>(IsFinalSpelledSealed)));
17159 Record->getLocation(), Record->getIdentifier(),
17169 "Broken injected-class-name");
17176 Tag->setBraceRange(BraceRange);
17179 if (Tag->isBeingDefined()) {
17180 assert(Tag->isInvalidDecl() &&
"We should already have completed it");
17181 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
17185 if (
auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
17187 if (RD->
hasAttr<SYCLSpecialClassAttr>()) {
17189 assert(Def &&
"The record is expected to have a completed definition");
17190 unsigned NumInitMethods = 0;
17191 for (
auto *Method : Def->methods()) {
17192 if (!Method->getIdentifier())
17194 if (Method->getName() ==
"__init")
17197 if (NumInitMethods > 1 || !Def->hasInitMethod())
17198 Diag(RD->
getLocation(), diag::err_sycl_special_type_num_init_method);
17207 Tag->setTopLevelDeclInObjCContainer();
17210 if (!Tag->isInvalidDecl())
17221 const RecordDecl *RD = dyn_cast<RecordDecl>(Tag);
17225 if (llvm::any_of(RD->
fields(),
17226 [](
const FieldDecl *FD) { return FD->isBitField(); }))
17227 Diag(BraceRange.
getBegin(), diag::warn_pragma_align_not_xl_compatible);
17237 assert(ObjCCtx ==
CurContext &&
"Mismatch of container contexts");
17250 Tag->setInvalidDecl();
17253 if (Tag->isBeingDefined()) {
17254 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
17268 bool IsMsStruct,
Expr *BitWidth) {
17278 diag::err_field_incomplete_or_sizeless))
17281 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
17283 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
17294 llvm::APSInt
Value;
17298 BitWidth = ICE.
get();
17301 if (
Value == 0 && FieldName)
17302 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
17304 if (
Value.isSigned() &&
Value.isNegative()) {
17306 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
17308 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
17315 return Diag(FieldLoc, diag::err_bitfield_too_wide)
17322 bool BitfieldIsOverwide =
Value.ugt(TypeWidth);
17326 bool CStdConstraintViolation =
17328 bool MSBitfieldViolation =
17329 Value.ugt(TypeStorageSize) &&
17331 if (CStdConstraintViolation || MSBitfieldViolation) {
17332 unsigned DiagWidth =
17333 CStdConstraintViolation ? TypeWidth : TypeStorageSize;
17334 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
17336 << !CStdConstraintViolation << DiagWidth;
17342 if (BitfieldIsOverwide && !FieldTy->
isBooleanType() && FieldName) {
17343 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
17357 DeclStart, D,
static_cast<Expr*
>(BitfieldWidth),
17400 diag::err_invalid_thread)
17408 switch (
Previous.getResultKind()) {
17415 PrevDecl =
Previous.getRepresentativeDecl();
17429 PrevDecl =
nullptr;
17433 PrevDecl =
nullptr;
17439 =
CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
17440 TSSL, AS, PrevDecl, &D);
17443 Record->setInvalidDecl();
17454 Record->addDecl(NewFD);
17472 bool Mutable,
Expr *BitWidth,
17478 bool InvalidDecl =
false;
17483 if (T.isNull() || T->containsErrors()) {
17484 InvalidDecl =
true;
17491 diag::err_field_incomplete_or_sizeless)) {
17493 Record->setInvalidDecl();
17494 InvalidDecl =
true;
17499 Record->setInvalidDecl();
17500 InvalidDecl =
true;
17506 if (T.hasAddressSpace() || T->isDependentAddressSpaceType() ||
17507 T->getBaseElementTypeUnsafe()->isDependentAddressSpaceType()) {
17508 Diag(Loc, diag::err_field_with_address_space);
17509 Record->setInvalidDecl();
17510 InvalidDecl =
true;
17516 if (T->isEventT() || T->isImageType() || T->isSamplerT() ||
17517 T->isBlockPointerType()) {
17518 Diag(Loc, diag::err_opencl_type_struct_or_union_field) << T;
17519 Record->setInvalidDecl();
17520 InvalidDecl =
true;
17525 "__cl_clang_bitfields",
LangOpts)) {
17526 Diag(Loc, diag::err_opencl_bitfields);
17527 InvalidDecl =
true;
17533 T.hasQualifiers()) {
17534 InvalidDecl =
true;
17535 Diag(Loc, diag::err_anon_bitfield_qualifiers);
17540 if (!InvalidDecl && T->isVariablyModifiedType()) {
17542 TInfo, T, Loc, diag::err_typecheck_field_variable_size))
17543 InvalidDecl =
true;
17548 diag::err_abstract_type_in_decl,
17550 InvalidDecl =
true;
17553 BitWidth =
nullptr;
17559 InvalidDecl =
true;
17560 BitWidth =
nullptr;
17565 if (!InvalidDecl && Mutable) {
17566 unsigned DiagID = 0;
17567 if (T->isReferenceType())
17568 DiagID =
getLangOpts().MSVCCompat ? diag::ext_mutable_reference
17569 : diag::err_mutable_reference;
17570 else if (T.isConstQualified())
17571 DiagID = diag::err_mutable_const;
17577 Diag(ErrLoc, DiagID);
17578 if (DiagID != diag::ext_mutable_reference) {
17580 InvalidDecl =
true;
17592 BitWidth, Mutable, InitStyle);
17596 if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
17597 Diag(Loc, diag::err_duplicate_member) << II;
17603 if (Record->isUnion()) {
17622 diag::ext_union_member_of_reference_type :
17623 diag::err_union_member_of_reference_type)
17646 if (T.isObjCGCWeak())
17647 Diag(Loc, diag::warn_attribute_weak_on_field);
17698 if (!FD->
hasAttr<UnavailableAttr>())
17700 UnavailableAttr::IR_ARCFieldWithOwnership, Loc));
17706 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
17707 diag::err_illegal_union_or_anon_struct_member)
17722 switch (ivarVisibility) {
17723 default: llvm_unreachable(
"Unknown visitibility kind");
17739 Expr *BitWidth = (
Expr*)BitfieldWidth;
17760 if (T->isReferenceType()) {
17761 Diag(Loc, diag::err_ivar_reference_type);
17766 else if (T->isVariablyModifiedType()) {
17768 TInfo, T, Loc, diag::err_typecheck_ivar_variable_size))
17782 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
17785 EnclosingContext = IMPDecl->getClassInterface();
17786 assert(EnclosingContext &&
"Implementation has no class interface!");
17789 EnclosingContext = EnclosingDecl;
17792 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
17794 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
17798 EnclosingContext = EnclosingDecl;
17803 DeclStart, Loc, II, T,
17804 TInfo, ac, (
Expr *)BitfieldWidth);
17809 if (PrevDecl &&
isDeclInScope(PrevDecl, EnclosingContext, S)
17810 && !isa<TagDecl>(PrevDecl)) {
17811 Diag(Loc, diag::err_duplicate_member) << II;
17838 !NewID->
isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
17839 Diag(Loc, diag::warn_ivars_in_interface);
17853 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
17861 if (!CD->IsClassExtension())
17873 DeclLoc, DeclLoc,
nullptr,
17879 AllIvarDecls.push_back(Ivar);
17892 if (!Record->hasUserDeclaredDestructor()) {
17899 for (
auto *
Decl : Record->decls()) {
17900 if (
auto *DD = dyn_cast<CXXDestructorDecl>(
Decl)) {
17901 if (DD->isInvalidDecl())
17905 assert(DD->isIneligibleOrNotSelected() &&
"Selecting a destructor but a destructor was already selected.");
17916 switch (OCS.BestViableFunction(S, Loc, Best)) {
17919 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(Best->Function));
17923 Msg = diag::err_ambiguous_destructor;
17928 Msg = diag::err_no_viable_destructor;
17939 Record->setInvalidDecl();
17946 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(OCS.begin()->Function));
17955 assert(EnclosingDecl &&
"missing record or interface decl");
17960 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
17964 case Decl::ObjCCategory:
17967 case Decl::ObjCImplementation:
17969 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
17974 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
17975 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
17977 if (CXXRecord && !CXXRecord->isDependentType())
17978 ComputeSelectedDestructor(*
this, CXXRecord);
17982 unsigned NumNamedMembers = 0;
17984 for (
const auto *I : Record->decls()) {
17985 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
17986 if (IFD->getDeclName())
18003 RecFields.push_back(FD);
18023 bool IsLastField = (i + 1 == Fields.end());
18032 (Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
18038 unsigned DiagID = 0;
18039 if (!Record->isUnion() && !IsLastField) {
18042 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
18046 }
else if (Record->isUnion())
18048 ? diag::ext_flexible_array_union_ms
18050 ? diag::ext_flexible_array_union_gnu
18051 : diag::err_flexible_array_union;
18052 else if (NumNamedMembers < 1)
18054 ? diag::ext_flexible_array_empty_aggregate_ms
18056 ? diag::ext_flexible_array_empty_aggregate_gnu
18057 : diag::err_flexible_array_empty_aggregate;
18061 << Record->getTagKind();
18067 if (CXXRecord && CXXRecord->getNumVBases() != 0)
18081 Diag(FD->
getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
18088 Record->setHasFlexibleArrayMember(
true);
18097 diag::err_field_incomplete_or_sizeless)) {
18103 if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
18106 Record->setHasFlexibleArrayMember(
true);
18107 if (!Record->isUnion()) {
18122 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
18124 diag::err_abstract_type_in_decl,
18129 if (Record && FDTTy->getDecl()->hasObjectMember())
18130 Record->setHasObjectMember(
true);
18131 if (Record && FDTTy->getDecl()->hasVolatileMember())
18132 Record->setHasVolatileMember(
true);
18139 }
else if (Record && Record->isUnion() &&
18151 FD->
addAttr(UnavailableAttr::CreateImplicit(
18152 Context,
"", UnavailableAttr::IR_ARCFieldWithOwnership,
18156 !Record->hasObjectMember()) {
18159 Record->setHasObjectMember(
true);
18162 if (BaseType->isRecordType() &&
18164 Record->setHasObjectMember(
true);
18165 else if (BaseType->isObjCObjectPointerType() ||
18166 BaseType.isObjCGCStrong())
18167 Record->setHasObjectMember(
true);
18172 !shouldIgnoreForRecordTriviality(FD)) {
18175 Record->setNonTrivialToPrimitiveDefaultInitialize(
true);
18178 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(
true);
18182 Record->setNonTrivialToPrimitiveCopy(
true);
18184 Record->setHasNonTrivialToPrimitiveCopyCUnion(
true);
18187 Record->setNonTrivialToPrimitiveDestroy(
true);
18188 Record->setParamDestroyedInCallee(
true);
18190 Record->setHasNonTrivialToPrimitiveDestructCUnion(
true);
18194 if (RT->getDecl()->getArgPassingRestrictions() ==
18202 Record->setHasVolatileMember(
true);
18210 bool Completed =
false;
18212 if (!CXXRecord->isInvalidDecl()) {
18215 I = CXXRecord->conversion_begin(),
18216 E = CXXRecord->conversion_end(); I != E; ++I)
18217 I.setAccess((*I)->getAccess());
18223 if (!CXXRecord->isDependentType()) {
18224 if (!CXXRecord->isInvalidDecl()) {
18228 if (CXXRecord->getNumVBases()) {
18230 CXXRecord->getFinalOverriders(FinalOverriders);
18232 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
18233 MEnd = FinalOverriders.end();
18236 SOEnd = M->second.end();
18237 SO != SOEnd; ++SO) {
18238 assert(SO->second.size() > 0 &&
18239 "Virtual function without overriding functions?");
18240 if (SO->second.size() == 1)
18247 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
18248 << (
const NamedDecl *)M->first << Record;
18249 Diag(M->first->getLocation(),
18250 diag::note_overridden_virtual_function);
18252 OM = SO->second.begin(),
18253 OMEnd = SO->second.end();
18255 Diag(OM->Method->getLocation(), diag::note_final_overrider)
18256 << (
const NamedDecl *)M->first << OM->Method->getParent();
18258 Record->setInvalidDecl();
18261 CXXRecord->completeDefinition(&FinalOverriders);
18269 Record->completeDefinition();
18275 auto IsFunctionPointer = [&](
const Decl *D) {
18276 const FieldDecl *FD = dyn_cast<FieldDecl>(D);
18280 if (isa<PointerType>(FieldType)) {
18290 (Record->hasAttr<RandomizeLayoutAttr>() ||
18291 (!Record->hasAttr<NoRandomizeLayoutAttr>() &&
18292 llvm::all_of(Record->decls(), IsFunctionPointer))) &&
18293 !Record->isUnion() && !
getLangOpts().RandstructSeed.empty() &&
18294 !Record->isRandomized()) {
18298 Record->reorderDecls(NewDeclOrdering);
18303 auto *Dtor = CXXRecord->getDestructor();
18304 if (Dtor && Dtor->isImplicit() &&
18306 CXXRecord->setImplicitDestructorIsDeleted();
18311 if (Record->hasAttrs()) {
18314 if (
const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
18316 IA->getRange(), IA->getBestCase(),
18317 IA->getInheritanceModel());
18323 bool CheckForZeroSize;
18325 CheckForZeroSize =
true;
18330 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
18332 CXXRecord->isCLike();
18334 if (CheckForZeroSize) {
18335 bool ZeroSize =
true;
18336 bool IsEmpty =
true;
18337 unsigned NonBitFields = 0;
18339 E = Record->field_end();
18340 (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
18342 if (I->isUnnamedBitfield()) {
18343 if (!I->isZeroLengthBitField(
Context))
18347 QualType FieldType = I->getType();
18359 diag::warn_zero_size_struct_union_in_extern_c :
18360 diag::warn_zero_size_struct_union_compat)
18361 << IsEmpty << Record->isUnion() << (NonBitFields > 1);
18367 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
18368 diag::ext_no_named_members_in_struct_union)
18369 << Record->isUnion();
18376 ID->setEndOfDefinitionLoc(RBrac);
18378 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
18380 ID->addDecl(ClsFields[i]);
18384 if (ID->getSuperClass())
18387 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
18388 assert(IMPDecl &&
"ActOnFields - missing ObjCImplementationDecl");
18389 for (
unsigned I = 0,
N = RecFields.size(); I !=
N; ++I)
18394 IMPDecl->setIvarLBraceLoc(LBrac);
18395 IMPDecl->setIvarRBraceLoc(RBrac);
18397 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
18405 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
18409 Diag(ClsFields[i]->getLocation(),
18410 diag::err_duplicate_ivar_declaration);
18411 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
18417 Diag(ClsFields[i]->getLocation(),
18418 diag::err_duplicate_ivar_declaration);
18419 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
18425 CDecl->addDecl(ClsFields[i]);
18427 CDecl->setIvarLBraceLoc(LBrac);
18428 CDecl->setIvarRBraceLoc(RBrac);
18436 llvm::APSInt &
Value,
18438 assert((T->isIntegralType(Context) || T->isEnumeralType()) &&
18439 "Integral type required!");
18442 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
18443 if (T->isSignedIntegerOrEnumerationType())
18445 return Value.getActiveBits() <= BitWidth;
18447 return Value.getMinSignedBits() <= BitWidth;
18455 assert((T->isIntegralType(Context) ||
18456 T->isEnumeralType()) &&
"Integral type required!");
18457 const unsigned NumTypes = 4;
18458 QualType SignedIntegralTypes[NumTypes] = {
18461 QualType UnsignedIntegralTypes[NumTypes] = {
18467 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
18468 : UnsignedIntegralTypes;
18469 for (
unsigned I = 0; I != NumTypes; ++I)
18482 llvm::APSInt EnumVal(IntWidth);
18502 EltTy =
Enum->getIntegerType();
18509 Val = Converted.
get();
18516 if (
Enum->isComplete()) {
18517 EltTy =
Enum->getIntegerType();
18526 .isWindowsMSVCEnvironment()) {
18527 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
18529 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
18553 Diag(IdLoc, diag::ext_enum_value_not_int)
18555 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
18567 if (
Enum->isDependentType())
18569 else if (!LastEnumConst) {
18578 if (
Enum->isFixed()) {
18579 EltTy =
Enum->getIntegerType();
18588 EltTy = LastEnumConst->
getType();
18591 if (EnumVal < LastEnumConst->getInitVal()) {
18603 if (T.isNull() ||
Enum->isFixed()) {
18607 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
18609 if (
Enum->isFixed())
18611 Diag(IdLoc, diag::err_enumerator_wrapped)
18615 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
18635 Diag(IdLoc, diag::warn_enum_value_overflow);
18639 Diag(IdLoc, diag::ext_enum_value_not_int)
18667 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
18688 cast_or_null<EnumConstantDecl>(lastEnumConst);
18704 PrevDecl =
nullptr;
18722 if (!TheEnumDecl->
isScoped() && isa<ValueDecl>(PrevDecl)) {
18730 "Received TagDecl when not in C++!");
18732 if (isa<EnumConstantDecl>(PrevDecl))
18733 Diag(IdLoc, diag::err_redefinition_of_enumerator) <<
Id;
18735 Diag(IdLoc, diag::err_redefinition) <<
Id;
18767 if (!BO->isAdditiveOp())
18775 InitExpr = BO->getLHS();
18779 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
18799 if (!
Enum->getIdentifier())
18803 if (
Enum->getNumPositiveBits() > 63 ||
Enum->getNumNegativeBits() > 64)
18812 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
18815 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
18819 llvm::APSInt Val = D->getInitVal();
18820 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
18823 DuplicatesVector DupVector;
18824 ValueToVectorMap EnumMap;
18828 for (
auto *Element : Elements) {
18842 EnumMap.insert({EnumConstantToKey(ECD), ECD});
18845 if (EnumMap.size() == 0)
18849 for (
auto *Element : Elements) {
18855 auto Iter = EnumMap.find(EnumConstantToKey(ECD));
18856 if (Iter == EnumMap.end())
18859 DeclOrVector& Entry = Iter->second;
18866 auto Vec = std::make_unique<ECDVector>();
18868 Vec->push_back(ECD);
18875 DupVector.emplace_back(std::move(Vec));
18879 ECDVector *Vec = Entry.get<ECDVector*>();
18881 if (*Vec->begin() == ECD)
18884 Vec->push_back(ECD);
18888 for (
const auto &Vec : DupVector) {
18889 assert(Vec->size() > 1 &&
"ECDVector should have at least 2 elements.");
18892 auto *FirstECD = Vec->front();
18893 S.
Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
18894 << FirstECD <<
toString(FirstECD->getInitVal(), 10)
18895 << FirstECD->getSourceRange();
18899 for (
auto *ECD : llvm::drop_begin(*Vec))
18900 S.
Diag(ECD->getLocation(), diag::note_duplicate_element)
18901 << ECD <<
toString(ECD->getInitVal(), 10)
18902 << ECD->getSourceRange();
18907 bool AllowMask)
const {
18908 assert(ED->
isClosedFlag() &&
"looking for value in non-flag or open enum");
18911 auto R =
FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
18912 llvm::APInt &FlagBits = R.first->second;
18916 const auto &EVal = E->getInitVal();
18918 if (EVal.isPowerOf2())
18919 FlagBits = FlagBits.zext(EVal.getBitWidth()) | EVal;
18931 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
18932 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
18943 if (
Enum->isDependentType()) {
18944 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
18946 cast_or_null<EnumConstantDecl>(Elements[i]);
18947 if (!ECD)
continue;
18965 unsigned NumNegativeBits = 0;
18966 unsigned NumPositiveBits = 0;
18968 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
18970 cast_or_null<EnumConstantDecl>(Elements[i]);
18971 if (!ECD)
continue;
18973 const llvm::APSInt &InitVal = ECD->
getInitVal();
18976 if (InitVal.isUnsigned() || InitVal.isNonNegative()) {
18979 unsigned ActiveBits = InitVal.getActiveBits();
18980 NumPositiveBits = std::max({NumPositiveBits, ActiveBits, 1u});
18982 NumNegativeBits = std::max(NumNegativeBits,
18983 (
unsigned)InitVal.getMinSignedBits());
18991 if (!NumPositiveBits && !NumNegativeBits)
18992 NumPositiveBits = 1;
18996 unsigned BestWidth;
19017 if (
Enum->isComplete()) {
19018 BestType =
Enum->getIntegerType();
19022 BestPromotionType = BestType;
19026 else if (NumNegativeBits) {
19030 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
19032 BestWidth = CharWidth;
19033 }
else if (Packed && NumNegativeBits <= ShortWidth &&
19034 NumPositiveBits < ShortWidth) {
19036 BestWidth = ShortWidth;
19037 }
else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
19039 BestWidth = IntWidth;
19043 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
19048 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
19049 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
19053 BestPromotionType = (BestWidth <= IntWidth ?
Context.
IntTy : BestType);
19058 if (Packed && NumPositiveBits <= CharWidth) {
19061 BestWidth = CharWidth;
19062 }
else if (Packed && NumPositiveBits <= ShortWidth) {
19065 BestWidth = ShortWidth;
19066 }
else if (NumPositiveBits <= IntWidth) {
19068 BestWidth = IntWidth;
19070 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
19072 }
else if (NumPositiveBits <=
19076 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
19080 assert(NumPositiveBits <= BestWidth &&
19081 "How could an initializer get larger than ULL?");
19084 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
19091 for (
auto *D : Elements) {
19092 auto *ECD = cast_or_null<EnumConstantDecl>(D);
19093 if (!ECD)
continue;
19102 llvm::APSInt InitVal = ECD->getInitVal();
19110 !
Enum->isFixed() &&
19113 NewWidth = IntWidth;
19115 }
else if (ECD->getType() == BestType) {
19125 NewWidth = BestWidth;
19130 InitVal = InitVal.extOrTrunc(NewWidth);
19131 InitVal.setIsSigned(NewSign);
19132 ECD->setInitVal(InitVal);
19135 if (ECD->getInitExpr() &&
19138 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
19146 ECD->setType(NewTy);
19149 Enum->completeDefinition(BestType, BestPromotionType,
19150 NumPositiveBits, NumNegativeBits);
19154 if (
Enum->isClosedFlag()) {
19155 for (
Decl *D : Elements) {
19157 if (!ECD)
continue;
19160 if (InitVal != 0 && !InitVal.isPowerOf2() &&
19168 if (
Enum->hasAttrs())
19178 AsmString, StartLoc,
19193 AsmLabelAttr *
Attr = AsmLabelAttr::CreateImplicit(
19200 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
19204 Diag(PrevDecl->
getLocation(), diag::warn_redefine_extname_not_applied)
19232 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
19233 if (!PrevDecl->
hasAttr<AliasAttr>())
19234 if (
NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
19242 return (dyn_cast_or_null<ObjCContainerDecl>(
CurContext));
19247 assert(FD &&
"Expected non-null FunctionDecl");
19259 auto IsEmittedForExternalSymbol = [
this, FD]() {
19279 if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host)
19284 if (IsEmittedForExternalSymbol())
19290 }
else if (
LangOpts.OpenMP > 45) {
19297 if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
19316 if (IsEmittedForExternalSymbol())
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
static const Builtin::Info BuiltinInfo[]
Defines enum values for all the target-independent builtin functions.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines the classes used to store parsed information about declaration-specifiers and decla...
Defines the C++ template declaration subclasses.
static bool isDeclExternC(const T &D)
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the clang::Expr interface and subclasses for C++ expressions.
static const Decl * getCanonicalDecl(const Decl *D)
static bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
static const GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
static bool isExternC(const NamedDecl *ND)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static bool hasAttr(const FunctionDecl *D, bool IgnoreImplicitAttr)
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
static void diagnoseImplicitlyRetainedSelf(Sema &S)
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static UnqualifiedTypeNameLookupResult lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc, const CXXRecordDecl *RD)
Tries to perform unqualified lookup of the type decls in bases for dependent class.
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD)
static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc)
static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S)
static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD, DeclaratorDecl *OldD)
If necessary, adjust the semantic declaration context for a qualified declaration to name the correct...
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken)
Determine whether the given result set contains either a type name or.
static void FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL)
static bool AllowOverloadingOfFunction(const LookupResult &Previous, ASTContext &Context, const FunctionDecl *New)
Determine whether overloading is allowed for a new function declaration considering prior declaration...
static TypeSourceInfo * TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID, ASTContext::GetBuiltinTypeError Error)
static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D)
static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New)
Check whether a redeclaration of an entity introduced by a using-declaration is valid,...
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK)
static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, const DeclContext *OldDC)
Determine what kind of declaration we're shadowing.
static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl< const Type * > &ValidTypes)
static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S)
mergeParamDeclAttributes - Copy attributes from the old parameter to the new one.
static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
Check the validity of a mulitversion function declaration.
static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old)
Merge alignment attributes from Old to New, taking into account the special semantics of C11's _Align...
static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous)
static bool CheckMultiVersionAdditionalDecl(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, MultiVersionKind NewMVKind, const TargetAttr *NewTA, const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec, const TargetClonesAttr *NewClones, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
Check the validity of a new function declaration being added to an existing multiversioned declaratio...
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint)
static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC)
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD)
Given that we are within the definition of the given function, will that definition behave like C99's...
static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, QualType T)
Determine whether the given integral value is representable within the given type T.
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef< Decl * > Elements, EnumDecl *Enum, QualType EnumType)
static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old)
checkNewAttributesAfterDef - If we already have a definition, check that there are no new attributes ...
static bool isClassCompatTagKind(TagTypeKind Tag)
Determine if tag kind is a class-key compatible with class for redeclaration (class,...
static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B)
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND)
static bool hasSimilarParameters(ASTContext &Context, FunctionDecl *Declaration, FunctionDecl *Definition, SmallVectorImpl< unsigned > &Params)
hasSimilarParameters - Determine whether the C++ functions Declaration and Definition have "nearly" m...
static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD)
Determine whether a class is C-like, according to the rules of C++ [dcl.typedef] for anonymous classe...
static FunctionDecl * CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay)
static Scope * getTagInjectionScope(Scope *S, const LangOptions &LangOpts)
Find the Scope in which a tag is implicitly declared if we see an elaborated type specifier in the sp...
static std::pair< diag::kind, SourceLocation > getNoteDiagForInvalidRedeclaration(const T *Old, const T *New)
static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous)
Apply special rules for handling extern "C" declarations.
static bool DeclHasAttr(const Decl *D, const Attr *A)
DeclhasAttr - returns true if decl Declaration already has the target attribute.
static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty)
static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl, const ConstInitAttr *CIAttr, bool AttrBeforeInit)
static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, const LookupResult &R)
static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc)
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
static bool checkGlobalOrExternCConflict(Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous)
Check for conflict between this global or extern "C" declaration and previous global or extern "C" de...
static bool isStdBuiltin(ASTContext &Ctx, FunctionDecl *FD, unsigned BuiltinID)
Determine whether a declaration matches a known function in namespace std.
@ InvalidAddrSpacePtrKernelParam
static bool isFromSystemHeader(SourceManager &SM, const Decl *D)
Returns true if the declaration is declared in a system header or from a system macro.
static const CXXRecordDecl * findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC)
Find the parent class with dependent bases of the innermost enclosing method context.
static bool shouldConsiderLinkage(const VarDecl *VD)
static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record)
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, const FunctionDecl *NewFD, bool CausesMV, MultiVersionKind MVKind)
static DeclContext * getTagInjectionContext(DeclContext *DC)
Find the DeclContext in which a tag is implicitly declared if we see an elaborated type specifier in ...
static bool EquivalentArrayTypes(QualType Old, QualType New, const ASTContext &Ctx)
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New)
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for redeclaration diagnostic message.
static bool MultiVersionTypesCompatible(MultiVersionKind Old, MultiVersionKind New)
static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old)
static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion)
We are trying to inject an anonymous member into the given scope; check if there's an existing declar...
static NamedDecl * DiagnoseInvalidRedeclaration(Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S)
Generate diagnostics for an invalid function redeclaration.
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name)
RebuildDeclaratorInCurrentInstantiation - Checks whether the given declarator needs to be rebuilt in ...
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc)
static bool hasParsedAttr(Scope *S, const Declarator &PD, ParsedAttr::Kind Kind)
ShadowedDeclKind
Enum describing the select options in diag::warn_decl_shadow.
static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S)
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, SmallVectorImpl< NamedDecl * > &Chaining)
InjectAnonymousStructOrUnionMembers - Inject the members of the anonymous struct or union AnonRecord ...
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
static ObjCIvarDecl::AccessControl TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility)
TranslateIvarVisibility - Translate visibility from a token ID to an AST enum value.
static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T)
static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT)
static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc)
static bool isDefaultStdCall(FunctionDecl *FD, Sema &S)
static bool diagnoseOpenCLTypes(Sema &Se, VarDecl *NewVD)
Returns true if there hasn't been any invalid type diagnosed.
static void RemoveUsingDecls(LookupResult &R)
Removes using shadow declarations from the lookup results.
static bool AttrCompatibleWithMultiVersion(attr::Kind Kind, MultiVersionKind MVKind)
static void filterNonConflictingPreviousTypedefDecls(Sema &S, TypedefNameDecl *Decl, LookupResult &Previous)
Typedef declarations don't have linkage, but they still denote the same entity if their types are the...
static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD, MultiVersionKind MVKind, const TargetAttr *TA)
Check the validity of a multiversion function declaration that is the first of its kind.
static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator, Sema &S)
static const NamedDecl * getDefinition(const Decl *D)
static bool isUsingDecl(NamedDecl *D)
static QualType TryToFixInvalidVariablyModifiedType(QualType T, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static bool hasDeducedAuto(DeclaratorDecl *DD)
static bool CheckTargetCausesMultiVersioning(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, const TargetAttr *NewTA, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
static void copyAttrFromTypedefToDecl(Sema &S, Decl *D, const TypedefType *TT)
static QualType getCoreType(QualType Ty)
static bool isMainFileLoc(const Sema &S, SourceLocation Loc)
static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD)
Check the target attribute of the function for MultiVersion validity.
static void CheckPoppedLabel(LabelDecl *L, Sema &S)
static bool isOutOfScopePreviousDeclaration(NamedDecl *, DeclContext *, ASTContext &)
Determines whether the given declaration is an out-of-scope previous declaration.
static StorageClass StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS)
StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to a VarDecl::StorageClass.
static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI, const VarDecl *VD)
Return the location of the capture if the given lambda captures the given variable VD,...
static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition)
static bool checkNonMultiVersionCompatAttributes(Sema &S, const FunctionDecl *FD, const FunctionDecl *CausedFD, MultiVersionKind MVKind)
static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D)
static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum)
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T)
static bool isIncompleteDeclExternC(Sema &S, const T *D)
Determine whether a variable is extern "C" prior to attaching an initializer.
static bool isAttributeTargetADefinition(Decl *D)
static Attr * getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD)
Return a CodeSegAttr from a containing class.
static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D)
Check for this common pattern:
static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, DeclContext *NewDC)
Determine whether a tag originally declared in context OldDC can be redeclared with an unqualified na...
static bool isRecordType(QualType T)
Defines the SourceManager interface.
const NestedNameSpecifier * Specifier
RAII object that pops an ExpressionEvaluationContext when exiting a function body.
ExitFunctionBodyRAII(Sema &S, bool IsLambda)
llvm::APInt getValue() const
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
virtual void HandleInlineFunctionDefinition(FunctionDecl *D)
This callback is invoked each time an inline (method or friend) function definition in a class is com...
virtual bool shouldSkipFunctionBody(Decl *D)
This callback is called for each function if the Parser was initialized with SkipFunctionBodies set t...
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getParenType(QualType NamedType) const
unsigned getIntWidth(QualType T) const
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
ExternCContextDecl * getExternCContextDecl() const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
QualType getObjCClassType() const
Represents the Objective-C Class type.
QualType getRecordType(const RecordDecl *Decl) const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
const LangOptions & getLangOpts() const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false)
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
void attachCommentsToJustParsedDecls(ArrayRef< Decl * > Decls, const Preprocessor *PP)
Searches existing comments for doc comments that should be attached to Decls.
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType UnsignedShortTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
void setcudaConfigureCallDecl(FunctionDecl *FD)
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
void ResetObjCLayout(const ObjCContainerDecl *CD)
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 'RHS' attributes and ret...
bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U)
Determine whether two function types are the same, ignoring pointer sizes in the return type and para...
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
@ GE_Missing_stdio
Missing a type from <stdio.h>
@ GE_Missing_type
Missing a type.
@ GE_Missing_ucontext
Missing a type from <ucontext.h>
@ GE_Missing_setjmp
Missing a type from <setjmp.h>
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Wrapper for source info for arrays.
SourceLocation getLBracketLoc() const
Expr * getSizeExpr() const
TypeLoc getElementLoc() const
SourceLocation getRBracketLoc() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Attr - This represents one attribute.
attr::Kind getKind() const
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
@ AS_Keyword
__ptr16, alignas(...), etc.
@ AS_Declspec
__declspec(...)
SourceRange getRange() const
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
AttributeFactory & getFactory() const
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
bool isCallingConv() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value.
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isCompoundAssignmentOp(Opcode Opc)
A binding in a decomposition declaration.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
bool doesNotEscape() const
This class is used for builtin types like 'int'.
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
bool performsCallback(unsigned ID, llvm::SmallVectorImpl< int > &Encoding) const
Determine whether this builtin has callback behavior (see llvm::AbstractCallSites for details).
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
bool isReturnsTwice(unsigned ID) const
Return true if we know this builtin can return twice.
bool allowTypeMismatch(unsigned ID) const
Determines whether a declaration of this builtin should be recognized even if the type doesn't match ...
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
bool isHeaderDependentFunction(unsigned ID) const
Returns true if this builtin requires appropriate header in other compilers.
bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like scanf in its formatting rules and, if so, set the index to the...
bool isInStdNamespace(unsigned ID) const
Determines whether this builtin is a C++ standard library function that lives in (possibly-versioned)...
bool isConstWithoutErrno(unsigned ID) const
Return true if this function has no side effects and doesn't read memory, except for possibly errno.
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like printf in its formatting rules and, if so, set the index to th...
const char * getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
bool isPredefinedRuntimeFunction(unsigned ID) const
Determines whether this builtin is a predefined compiler-rt/libgcc function, such as "__clear_cache",...
bool isPure(unsigned ID) const
Return true if this function has no side effects.
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
bool isConst(unsigned ID) const
Return true if this function has no side effects and doesn't read memory.
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a base class of a C++ class.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
Represents a call to a C++ constructor.
bool isElidable() const
Whether this construction is elidable.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents a C++ constructor within a class.
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Represents a C++ conversion function within a class.
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr)
Represents a C++ destructor within a class.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
A mapping from each virtual member function to its set of final overriders.
Represents a static or instance method of a struct/union/class.
void addOverriddenMethod(const CXXMethodDecl *MD)
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Qualifiers getMethodQualifiers() const
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
base_class_iterator bases_end()
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
base_class_iterator bases_begin()
capture_const_range captures() const
bool hasDefinition() const
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
LambdaCaptureDefault getLambdaCaptureDefault() const
void setDescribedClassTemplate(ClassTemplateDecl *Template)
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
char * location_data() const
Retrieve the data associated with the source-location information.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
bool isCallToStdMove() const
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastKind getCastKind() const
static CharSourceRange getCharRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a function specialization at template class scope.
static ClassScopeFunctionSpecializationDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, CXXMethodDecl *FD, bool HasExplicitTemplateArgs, const TemplateArgumentListInfo &TemplateArgs)
Declaration of a class template.
ConditionalOperator - The ?: ternary operator.
const llvm::APInt & getSize() const
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isObjCContainer() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void removeDecl(Decl *D)
Removes a declaration from this context.
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Decl::Kind getDeclKind() const
DeclContext * getNonTransparentContext()
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isModulePrivateSpecified() const
bool hasAutoTypeSpec() const
static const TST TST_typename
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error.
void ClearStorageClassSpecs()
static const TST TST_underlyingType
bool isNoreturnSpecified() const
TST getTypeSpecType() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
void SetRangeEnd(SourceLocation Loc)
static const TST TST_interface
static const TST TST_typeofExpr
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
void SetRangeStart(SourceLocation Loc)
SourceLocation getNoreturnSpecLoc() const
bool isExternInLinkageSpec() const
static const TST TST_union
SCS
storage-class-specifier
SourceLocation getExplicitSpecLoc() const
SourceLocation getModulePrivateSpecLoc() const
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
ParsedType getRepAsType() const
void UpdateTypeRep(ParsedType Rep)
TSCS getThreadStorageClassSpec() const
ParsedAttributes & getAttributes()
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
SourceLocation getConstSpecLoc() const
SourceRange getExplicitSpecRange() const
Expr * getRepAsExpr() const
static const TST TST_enum
static const TST TST_decltype
static bool isDeclRep(TST T)
bool isInlineSpecified() const
SourceLocation getRestrictSpecLoc() const
static const TST TST_class
void ClearConstexprSpec()
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
static const TST TST_atomic
SourceLocation getThreadStorageClassSpecLoc() const
Decl * getRepAsDecl() const
bool isFriendSpecified() const
static const TST TST_unspecified
SourceLocation getAtomicSpecLoc() const
SourceLocation getVirtualSpecLoc() const
SourceLocation getConstexprSpecLoc() const
CXXScopeSpec & getTypeSpecScope()
SourceLocation getTypeSpecTypeLoc() const
void UpdateExprRep(Expr *Rep)
static const TSCS TSCS_thread_local
static const TST TST_error
ExplicitSpecifier getExplicitSpecifier() const
bool isTypeSpecOwned() const
SourceLocation getInlineSpecLoc() const
SourceLocation getUnalignedSpecLoc() const
SourceLocation getVolatileSpecLoc() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
static const TST TST_typeofType
static const TST TST_auto
ConstexprSpecKind getConstexprSpecifier() const
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
bool isInStdNamespace() const
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setAttrs(const AttrVec &Attrs)
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Module * getOwningModuleForLinkage(bool IgnoreLinkage=false) const
Get the module that owns this declaration for linkage purposes.
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void setTopLevelDeclInObjCContainer(bool V=true)
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_Undeclared
A friend of a previously-undeclared entity.
@ FOK_None
Not a friend object.
@ FOK_Declared
A friend of a previously-declared entity.
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
bool isReferenced() const
Whether any declaration of this entity was referenced.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
@ OBJC_TQ_CSNullability
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
bool isInvalidDecl() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
@ IDNS_Ordinary
Ordinary names.
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
void setLexicalDeclContext(DeclContext *DC)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
The name of a declaration.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
@ CXXConversionFunctionName
Represents a ValueDecl that came out of a declarator.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumTemplateParameterLists() const
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Expr * getAsmLabel() const
FunctionDefinitionKind getFunctionDefinitionKind() const
const ParsedAttributes & getAttributes() const
void setRedeclaration(bool Val)
SourceLocation getIdentifierLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
Expr * getTrailingRequiresClause()
Sets a trailing requires clause for this declarator.
void setInvalidType(bool Val=true)
TemplateParameterList * getInventedTemplateParameterList() const
The template parameter list generated from the explicit template parameters along with any invented t...
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
bool isRedeclaration() const
const ParsedAttributesView & getDeclarationAttributes() const
const DecompositionDeclarator & getDecompositionDeclarator() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
bool isFunctionDefinition() const
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
bool hasInitializer() const
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
void takeAttributes(ParsedAttributes &attrs)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
IdentifierInfo * getIdentifier() const
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
bool isInvalidType() const
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
bool isStaticMember()
Returns true if this declares a static member.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
A decomposition declaration.
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl * > Bindings)
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
SourceRange getSourceRange() const
SourceLocation getLSquareLoc() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Concrete class used by the front-end to report problems and issues.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
An instance of this object exists for each enum constant that is defined.
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
const Expr * getInitExpr() const
const llvm::APSInt & getInitVal() const
enumerator_range enumerators() const
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
void setIntegerType(QualType T)
Set the underlying integer type.
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
bool isComplete() const
Returns true if this can be considered a complete type.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
bool isClosedFlag() const
Returns true if this enum is annotated with flag_enum and isn't annotated with enum_extensibility(ope...
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
void setPromotionType(QualType T)
Set the promotion type.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EvaluatedExprVisitor - This class visits 'Expr *'s.
Store information needed for an explicit specifier.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Represents difference between two FPOptions values.
bool isFPConstrained() const
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Represents a function declaration or definition.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
bool isPure() const
Whether this virtual function is pure, i.e.
ConstexprSpecKind getConstexprKind() const
void setPreviousDeclaration(FunctionDecl *PrevDecl)
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
void setHasSkippedBody(bool Skipped=true)
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
bool hasWrittenPrototype() const
Whether this function has a written prototype.
void setWillHaveBody(bool V=true)
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isDeleted() const
Whether this function has been deleted.
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
void setPure(bool P=true)
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
@ TK_MemberSpecialization
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isReplaceableGlobalAllocationFunction(Optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
void setHasInheritedPrototype(bool P=true)
State that this function inherited its prototype from a previous declaration.
bool isExternC() const
Determines whether this function is a function with external, C linkage.
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
FunctionDecl * getDefinition()
Get the definition for this declaration.
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
void setRangeEnd(SourceLocation E)
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
bool isDefaulted() const
Whether this function is defaulted.
void setIneligibleOrNotSelected(bool II)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
void setConstexprKind(ConstexprSpecKind CSK)
void setDefaulted(bool D=true)
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
bool isGlobal() const
Determines whether this is a global function.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
bool hasInheritedPrototype() const
Whether this function inherited its prototype from a previous declaration.
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
DeclarationNameInfo getNameInfo() const
void setDeletedAsWritten(bool D=true)
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
void setHasImplicitReturnZero(bool IRZ)
State that falling off this function implicitly returns null/zero.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
void mergePrevDecl(FunctionTemplateDecl *Prev)
Merge Prev with our RedeclarableTemplateDecl::Common.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Wrapper for source info for functions.
A class which abstracts out some details necessary for making a call.
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
ExtInfo withProducesResult(bool producesResult) const
unsigned getRegParm() const
bool getNoCallerSavedRegs() const
ExtInfo withNoReturn(bool noReturn) const
bool getHasRegParm() const
bool getProducesResult() const
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
ExtInfo withRegParm(unsigned RegParm) const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
unsigned getRegParmType() const
CallingConv getCallConv() const
QualType getReturnType() const
bool getCmseNSCallAttr() const
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
StringRef getName() const
Return the actual identifier string.
iterator - Iterate over the decls of a specified declaration name.
iterator begin(DeclarationName Name)
begin - Returns an iterator for decls with the name 'Name'.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void InsertDeclAfter(iterator Pos, NamedDecl *D)
Insert the given declaration after the given iterator position.
iterator end()
end - Returns an iterator that has 'finished'.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
void setInherited(bool I)
Description of a constructor that was inherited from a base class.
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
bool isResolvedMSAsmLabel() const
LabelStmt * getStmt() const
bool isMSAsmLabel() const
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
bool requiresStrictPrototypes() const
Returns true if functions without prototypes or functions with an identifier list (aka K&R C function...
clang::ObjCRuntime ObjCRuntime
std::string getOpenCLVersionString() const
Return the OpenCL C or C++ for OpenCL language name and version as a string.
bool implicitFunctionsAllowed() const
Returns true if implicit function declarations are allowed in the current language mode.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
void push_back(const T &LocalValue)
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Represents a linkage specification.
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
void InstantiatedLocal(const Decl *D, Decl *Inst)
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
DeclClass * getAsSingle() const
bool empty() const
Return true if no decls were found.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
@ AmbiguousTagHiding
Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
virtual unsigned getStaticLocalNumber(const VarDecl *VD)=0
Static locals are numbered by source order.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Describes a module or submodule.
SourceLocation DefinitionLoc
The location of the module definition.
Module * Parent
The parent of this module.
bool isPrivateModule() const
bool isModulePurview() const
Does this Module scope describe part of the purview of a named C++ module?
bool isModuleMapModule() const
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
StringRef getPrimaryModuleInterfaceName() const
Get the primary module interface name from a partition.
bool isModulePartition() const
Is this a module partition.
bool isGlobalModule() const
Does this Module scope describe a fragment of the global module within some C++ module.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
bool isLinkageValid() const
True if the computed linkage is valid.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Visibility getVisibility() const
Determines the visibility of this entity.
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool hasLinkageBeenComputed() const
True if something has required us to compute the linkage of this declaration.
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context,...
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
bool hasLinkage() const
Determine whether this declaration has linkage.
bool isExternallyVisible() const
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine if the declaration obeys the reserved identifier rules of the given language.
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represent a C++ namespace.
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Class that aids in the construction of nested-name-specifiers along with source-location information ...
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool containsErrors() const
Whether this nested name specifier contains an error.
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
ObjCCategoryDecl - Represents a category declaration.
ObjCCompatibleAliasDecl - Represents alias of a class.
ObjCContainerDecl - Represents a container for method declarations.
ObjCIvarDecl * getIvarDecl(IdentifierInfo *Id) const
getIvarDecl - This method looks up an ivar in this ContextDecl.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Represents an ObjC class declaration.
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
known_extensions_range known_extensions() const
ObjCIvarDecl - Represents an ObjC instance variable.
static ObjCIvarDecl * Create(ASTContext &C, ObjCContainerDecl *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW=nullptr, bool synthesized=false)
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
param_const_iterator param_end() const
param_const_iterator param_begin() const
const ParmVarDecl *const * param_const_iterator
ParmVarDecl *const * param_iterator
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Wrapper for void* pointer.
static OpaquePtr make(PtrTy P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
MapType::iterator iterator
SmallVectorImpl< UniqueVirtualMethod >::iterator overriding_iterator
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
unsigned getNumExprs() const
Return the number of expressions in this paren list.
void setRParenLoc(SourceLocation Loc)
TypeLoc getInnerLoc() const
void setLParenLoc(SourceLocation Loc)
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
ObjCDeclQualifier getObjCDeclQualifier() const
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
QualType getOriginalType() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
ParsedAttr - Represents a syntactic attribute.
static const ParsedAttributesView & none()
bool hasAttribute(ParsedAttr::Kind K) const
ParsedAttributes - A collection of parsed attributes.
AttributePool & getPool() const
unsigned getDiagID() const
TypeLoc getPointeeLoc() const
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
HeaderSearch & getHeaderSearchInfo() const
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
StringRef getLastMacroWithSpelling(SourceLocation Loc, ArrayRef< TokenValue > Tokens) const
Return the name of the macro defined before Loc that has spelling Tokens.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
PrimitiveDefaultInitializeKind
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
QualType withoutLocalFastQualifiers() const
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
bool isObjCGCStrong() const
true when Type is objc's strong.
bool isConstQualified() const
Determine whether this type is const-qualified.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
@ PCK_Trivial
The type does not fall into any of the following categories.
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
ObjCLifetime getObjCLifetime() const
Represents a struct/union/class.
bool hasObjectMember() const
field_range fields() const
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
virtual void completeDefinition()
Note that the definition of this type is now complete.
@ APK_CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
redecl_iterator redecls_end() const
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
void setNRVOCandidate(const VarDecl *Var)
Set the variable that might be used for the named return value optimization.
Scope - A scope is a transient data structure that is used while parsing the program.
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
DeclContext * getEntity() const
Get the entity corresponding to this scope.
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
@ DeclScope
This is a scope that can contain a declaration.
Mode getAlignMode() const
A class which encapsulates the logic for delaying diagnostics during parsing and other processing.
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
static NameClassification DependentNonType()
static NameClassification VarTemplate(TemplateName Name)
static NameClassification Unknown()
static NameClassification OverloadSet(ExprResult E)
static NameClassification UndeclaredTemplate(TemplateName Name)
static NameClassification FunctionTemplate(TemplateName Name)
static NameClassification NonType(NamedDecl *D)
static NameClassification Concept(TemplateName Name)
static NameClassification UndeclaredNonType()
static NameClassification TypeTemplate(TemplateName Name)
static NameClassification Error()
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
A generic diagnostic builder for errors which may or may not be deferred.
Sema - This implements semantic analysis and AST building for C.
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, int Priority)
Attribute merging methods. Return true if a new attribute was added.
StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs)
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
Attr * getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition)
Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a containing class.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
void ActOnObjCContainerStartDefinition(ObjCContainerDecl *IDecl)
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Scope * getCurScope() const
Retrieve the parser's current scope.
void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls)
MergeTypedefNameDecl - We just parsed a typedef 'New' which has the same name and scope as a previous...
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6....
void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S)
Register the given locally-scoped extern "C" declaration so that it can be found later for redeclarat...
BTFDeclTagAttr * mergeBTFDeclTagAttr(Decl *D, const BTFDeclTagAttr &AL)
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method,...
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false)
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
Decl * ActOnIvar(Scope *S, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, tok::ObjCKeywordKind visibility)
ActOnIvar - Each ivar field of an objective-c class is passed into this in order to create an IvarDec...
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
Decl * ActOnParamDeclarator(Scope *S, Declarator &D)
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
LookupNameKind
Describes the kind of name lookup to perform.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupNestedNameSpecifierName
Look up of a name that precedes the '::' scope resolution operator in C++.
@ LookupLocalFriendName
Look up a friend of a local class.
@ LookupRedeclarationWithLinkage
Look up an ordinary name that is going to be redeclared as a name with linkage.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
void ActOnPopScope(SourceLocation Loc, Scope *S)
Scope actions.
EnforceTCBAttr * mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL)
Decl * ActOnSkippedFunctionBody(Decl *Decl)
QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init)
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
@ NTCUC_DefaultInitializedObject
bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn)
MergeFunctionDecl - We just parsed a function 'New' from declarator D which has the same name and sco...
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV)
void ActOnTagDefinitionError(Scope *S, Decl *TagDecl)
ActOnTagDefinitionError - Invoked when there was an unrecoverable error parsing the definition of a t...
void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body)
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, TypeVisibilityAttr::VisibilityType Vis)
DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, IdentifierInfo *II)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceRange BraceRange)
ActOnTagFinishDefinition - Invoked once we have finished parsing the definition of a tag (enumeration...
FunctionEmissionStatus
Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
PragmaClangSection PragmaClangRodataSection
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
WebAssemblyImportNameAttr * mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL)
void ActOnExitFunctionContext()
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo &ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
DeduceAutoResult DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, Optional< unsigned > DependentDeductionDepth=None, bool IgnoreConstraints=false)
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Preprocessor & getPreprocessor() const
void deduceOpenCLAddressSpace(ValueDecl *decl)
PragmaStack< StringLiteral * > CodeSegStack
void AddRangeBasedOptnone(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based o...
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
DLLImportAttr * mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI)
static NamedDecl * getAsTemplateNameDecl(NamedDecl *D, bool AllowFunctionTemplates=true, bool AllowDependent=true)
Try to interpret the lookup result D as a template-name.
bool CheckForConstantInitializer(Expr *e, QualType t)
type checking declaration initializers (C99 6.7.8)
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions,...
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
ErrorAttr * mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI, StringRef NewUserDiagnostic)
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
void CheckMain(FunctionDecl *FD, const DeclSpec &D)
void AddKnownFunctionAttributes(FunctionDecl *FD)
Adds any function attributes that we know a priori based on the declaration of this function.
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
void ActOnReenterFunctionContext(Scope *S, Decl *D)
Push the parameters of D, which must be a function, into scope.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S)
isTagName() - This method is called for error recovery purposes only to determine if the specified na...
bool CheckRedeclarationExported(NamedDecl *New, NamedDecl *Old)
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
VisibilityAttr * mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, VisibilityAttr::VisibilityType Vis)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
bool LookupBuiltin(LookupResult &R)
Lookup a builtin function, when name lookup would otherwise fail.
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used.
NamedDecl * LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc)
LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
bool IsRedefinitionInModule(const NamedDecl *New, const NamedDecl *Old) const
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
void PopExpressionEvaluationContext()
PragmaStack< StringLiteral * > ConstSegStack
bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S)
isMicrosoftMissingTypename - In Microsoft mode, within class scope, if a CXXScopeSpec's type is equal...
SmallVector< VarDecl *, 4 > ExternalDeclarations
All the external declarations encoutered and used in the TU.
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)
Add gsl::Pointer attribute to std::container::iterator.
bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn)
We've just determined that Old and New both appear to be definitions of the same variable.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
void ProcessPragmaWeak(Scope *S, Decl *D)
bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Decl * BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy)
BuildAnonymousStructOrUnion - Handle the declaration of an anonymous structure or union.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
bool UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *TheDecl)
void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld)
MergeVarDeclTypes - We parsed a variable 'New' which has the same name and scope as a previous declar...
llvm::DenseMap< IdentifierInfo *, AsmLabelAttr * > ExtnameUndeclaredIdentifiers
ExtnameUndeclaredIdentifiers - Identifiers contained in #pragma redefine_extname before declared.
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
void PushFunctionScope()
Enter a new function scope.
ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, NamedDecl *Found, SourceLocation NameLoc, const Token &NextToken)
Act on the result of classifying a name as a specific non-type declaration.
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
void CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
sema::LambdaScopeInfo * PushLambdaScope()
@ UPPC_FixedUnderlyingType
The fixed underlying type of an enumeration.
@ UPPC_EnumeratorValue
The enumerator value.
@ UPPC_Initializer
An initializer.
@ UPPC_DeclarationType
The type of an arbitrary declaration.
@ UPPC_DeclarationQualifier
A declaration qualifier.
@ UPPC_DataMemberType
The type of a data member.
@ UPPC_BitFieldWidth
The size of a bit-field.
void checkAllowedCUDAInitializer(VarDecl *VD)
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
void DiagnoseInvalidJumps(Stmt *Body)
SourceLocation CurInitSegLoc
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=None, OverloadCandidateParamOrder PO={})
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
NamedDecl * findLocallyScopedExternCDecl(DeclarationName Name)
Look for a locally scoped extern "C" declaration by the given name.
bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old)
We've determined that New is a redeclaration of Old.
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, SourceLocation ReturnLoc, Expr *&RetExpr, const AutoType *AT)
Deduce the return type for a function from a returned expression, per C++1y [dcl.spec....
void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(Decl *D, SmallVectorImpl< FunctionDecl * > &Bases)
Register D as specialization of all base functions in Bases in the current omp begin/end declare vari...
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
MinSizeAttr * mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI)
NamedDecl * getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R)
Return the declaration shadowed by the given typedef D, or null if it doesn't shadow any declaration ...
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
const LangOptions & LangOpts
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings=None)
bool isReachable(const NamedDecl *D)
Determine whether a declaration is reachable.
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
CXXRecordDecl * getStdBadAlloc() const
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident)
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
PragmaClangSection PragmaClangRelroSection
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
bool TemplateParameterListsAreEqual(TemplateParameterList *New, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
void CheckCXXDefaultArguments(FunctionDecl *FD)
CheckCXXDefaultArguments - Verify that the default arguments for a function declaration are well-form...
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
WebAssemblyImportModuleAttr * mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL)
void MaybeAddCUDAConstantAttr(VarDecl *VD)
May add implicit CUDAConstantAttr attribute to VD, depending on VD and current compilation settings.
void AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based n...
PragmaStack< AlignPackInfo > AlignPackStack
bool canDelayFunctionBody(const Declarator &D)
Determine whether we can delay parsing the body of a function or function template until it is used,...
PragmaStack< StringLiteral * > BSSSegStack
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true, bool AllowNonTemplateFunctions=false)
DeclContext * getCurLexicalContext() const
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
bool hasExplicitCallingConv(QualType T)
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, CorrectionCandidateCallback *CCC=nullptr)
Perform name lookup on the given name, classifying it based on the results of name lookup and the fol...
NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK)
Given a non-tag type declaration, returns an enum useful for indicating what kind of non-tag type thi...
void ExitDeclaratorContext(Scope *S)
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI)
Diagnose shadowing for variables shadowed in the lambda record LambdaRD when these variables are capt...
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void AddCFAuditedAttribute(Decl *D)
AddCFAuditedAttribute - Check whether we're currently within '#pragma clang arc_cf_code_audited' and,...
void DiagnoseUnusedButSetDecl(const VarDecl *VD)
If VD is set but not otherwise used, diagnose, for a parameter or a variable.
void CheckMSVCRTEntryPoint(FunctionDecl *FD)
Decl * ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, SourceLocation IdLoc, IdentifierInfo *Id, const ParsedAttributesView &Attrs, SourceLocation EqualLoc, Expr *Val)
sema::FunctionScopeInfo * getCurFunction() const
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
FunctionDecl * CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID, SourceLocation Loc)
Scope * getNonFieldDeclScope(Scope *S)
getNonFieldDeclScope - Retrieves the innermost scope, starting from S, where a non-field would be dec...
void ActOnPragmaWeakID(IdentifierInfo *WeakName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc)
ActOnPragmaWeakID - Called on well formed #pragma weak ident.
bool CheckNontrivialField(FieldDecl *FD)
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
HLSLNumThreadsAttr * mergeHLSLNumThreadsAttr(Decl *D, const AttributeCommonInfo &AL, int X, int Y, int Z)
llvm::DenseMap< const VarDecl *, int > RefsMinusAssignments
Increment when we find a reference; decrement when we find an ignored assignment.
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl, SourceLocation FinalLoc, bool IsFinalSpelledSealed, bool IsAbstract, SourceLocation LBraceLoc)
ActOnStartCXXMemberDeclarations - Invoked when we have parsed a C++ record definition's base-specifie...
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth)
VerifyBitField - verifies that a bit field expression is an ICE and has the correct width,...
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
ExprResult DefaultLvalueConversion(Expr *E)
MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, bool BestCase, MSInheritanceModel Model)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
StringLiteral * CurInitSeg
Last section used with #pragma init_seg.
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD)
AddOverriddenMethods - See if a method overrides any in the base classes, and if so,...
InternalLinkageAttr * mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL)
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init)
bool ActOnDuplicateDefinition(Decl *Prev, SkipBodyInfo &SkipBody)
Perform ODR-like check for C/ObjC when merging tag types from modules.
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
@ NotForRedeclaration
The lookup is a reference to this name that is not for the purpose of redeclaring the name.
@ ForVisibleRedeclaration
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
@ ForExternalRedeclaration
The lookup results will be used for redeclaration of a name with external linkage; non-visible lookup...
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true, bool ConsiderRequiresClauses=true)
void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D)
Act on D, a function definition inside of an omp [begin/end] assumes.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD, const LookupResult &Previous)
May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, depending on FD and the current co...
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration.
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
ObjCContainerDecl * getObjCDeclContext() const
DLLExportAttr * mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI)
bool isInOpenMPDeclareVariantScope() const
Can we exit an OpenMP declare variant scope at the moment.
DeclContext * OriginalLexicalContext
Generally null except when we temporarily switch decl contexts, like in.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
CodeSegAttr * mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
SectionAttr * mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, QualType NewT, QualType OldT)
Determines if we can perform a correct type check for D as a redeclaration of PrevDecl.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
@ NTK_TemplateTemplateArgument
void ActOnObjCContainerFinishDefinition()
SourceManager & getSourceManager() const
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld)
Completes the merge of two function declarations that are known to be compatible.
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, const ParsedAttributesView &Attr)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
bool areMultiversionVariantFunctionsCompatible(const FunctionDecl *OldFD, const FunctionDecl *NewFD, const PartialDiagnostic &NoProtoDiagID, const PartialDiagnosticAt &NoteCausedDiagIDAt, const PartialDiagnosticAt &NoSupportDiagIDAt, const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, bool ConstexprSupported, bool CLinkageMayDiffer)
Checks if the variant/multiversion functions are compatible.
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e....
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
PragmaClangSection PragmaClangTextSection
PragmaClangSection PragmaClangDataSection
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, SmallVectorImpl< FunctionDecl * > &Bases)
The declarator D defines a function in the scope S which is nested in an omp begin/end declare varian...
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
void * SkippedDefinitionContext
ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, SourceLocation NameLoc)
Act on the result of classifying a name as an undeclared (ADL-only) non-type declaration.
void ActOnPragmaRedefineExtname(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaRedefineExtname - Called on well formed #pragma redefine_extname oldname newname.
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
MaybeODRUseExprSet MaybeODRUseExprs
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
Helpers for dealing with blocks and functions.
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
void ActOnObjCReenterContainerContext(ObjCContainerDecl *ObjCCtx)
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI)
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
void CheckCompleteVariableDeclaration(VarDecl *VD)
DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef< Decl * > Group)
void setFunctionHasBranchProtectedScope()
void MergeVarDecl(VarDecl *New, LookupResult &Previous)
MergeVarDecl - We just parsed a variable 'New' which has the same name and scope as a previous declar...
FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl, bool Final=false)
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, SourceLocation NameLoc, bool IsTemplateTypeArg)
Attempt to behave like MSVC in situations where lookup of an unqualified type name has failed in a de...
EnforceTCBLeafAttr * mergeEnforceTCBLeafAttr(Decl *D, const EnforceTCBLeafAttr &AL)
@ CCEK_Enumerator
Enumerator value with fixed underlying type.
void ActOnLastBitfield(SourceLocation DeclStart, SmallVectorImpl< Decl * > &AllIvarDecls)
ActOnLastBitfield - This routine handles synthesized bitfields rules for class and class extensions.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool IsForUsingDecl)
Determine whether the given New declaration is an overload of the declarations in Old.
@ Ovl_NonFunction
This is not an overload because the lookup results contain a non-function.
@ Ovl_Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
@ Ovl_Match
This is not an overload because the signature exactly matches an existing declaration.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
@ FirstDecl
Parsing the first decl in a TU.
void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FunctionDecl *FD)
If this function is a C++ replaceable global allocation function (C++2a [basic.stc....
bool inferObjCARCLifetime(ValueDecl *decl)
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
FormatAttr * mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Format, int FormatIdx, int FirstArg)
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated",...
@ AMK_None
Don't merge availability attributes at all.
@ AMK_Override
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
@ AMK_ProtocolImplementation
Merge availability attributes for an implementation of a protocol requirement.
@ AMK_OptionalProtocolImplementation
Merge availability attributes for an implementation of an optional protocol requirement.
@ AMK_Redeclaration
Merge availability attributes for a redeclaration, which requires an exact match.
void ActOnDocumentableDecls(ArrayRef< Decl * > Group)
void CheckStaticLocalForDllExport(VarDecl *VD)
Check if VD needs to be dllexport/dllimport due to being in a dllexport/import function.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e....
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context)
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD)
Only called on function definitions; if there is a MSVC #pragma optimize in scope,...
bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl)
Checks if the new declaration declared in dependent context must be put in the same redeclaration cha...
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void DiscardCleanupsInEvaluationContext()
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
void makeMergedDefinitionVisible(NamedDecl *ND)
Make a merged definition of an existing hidden definition ND visible at the specified location.
UuidAttr * mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, StringRef UuidAsWritten, MSGuidDecl *GuidDecl)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness,...
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
Decl * BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, RecordDecl *Record)
BuildMicrosoftCAnonymousStruct - Handle the declaration of an Microsoft C anonymous structure.
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
RedeclarationKind forRedeclarationInCurContext()
NamedDecl * ActOnTypedefDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous)
PragmaStack< StringLiteral * > DataSegStack
void deduceClosureReturnType(sema::CapturingScopeInfo &CSI)
Deduce a block or lambda's return type based on the return statements present in the body.
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D)
Common checks for a parameter-declaration that should apply to both function parameters and non-type ...
@ TPC_FriendFunctionTemplate
@ TPC_ClassTemplateMember
@ TPC_FriendFunctionTemplateDefinition
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name,...
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
void DiagnoseUnusedDecl(const NamedDecl *ND)
DiagnoseUnusedDecl - Emit warnings about declarations that are not used unless they are marked attr(u...
void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, const WeakInfo &W)
DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak applied to it,...
void ActOnUninitializedDecl(Decl *dcl)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
TypedefDecl * ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo)
Subroutines of ActOnDeclarator().
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
HLSLShaderAttr * mergeHLSLShaderAttr(Decl *D, const AttributeCommonInfo &AL, HLSLShaderAttr::ShaderType ShaderType)
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
Decl * ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth)
ActOnField - Each field of a C struct/union is passed into this in order to create a FieldDecl object...
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false)
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &... Args)
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
void ActOnCXXForRangeDecl(Decl *D)
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant,...
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, bool IsTemplateId)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
llvm::MapVector< IdentifierInfo *, llvm::SetVector< WeakInfo, llvm::SmallVector< WeakInfo, 1u >, llvm::SmallDenseSet< WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly > > > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
PragmaClangSection PragmaClangBSSSection
Decl * ActOnDeclarator(Scope *S, Declarator &D)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void CheckAlignasUnderalignment(Decl *D)
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, bool IsAddressOfOperand)
Act on the result of classifying a name as an undeclared member of a dependent base class.
SwiftNameAttr * mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, StringRef Name)
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
void ActOnPragmaWeakAlias(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
void CheckVariableDeclarationType(VarDecl *NewVD)
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
CXXSpecialMember
Kinds of C++ special members.
SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD)
Invoked when we enter a tag definition that we're skipping.
bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, Expr *Init)
std::string getCudaConfigureFuncName() const
Returns the name of the launch configuration function.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
llvm::SmallPtrSet< const NamedDecl *, 4 > TypoCorrectedFunctionDefinitions
The function definitions which were renamed as part of typo-correction to match their respective decl...
Decl * ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
void AddSectionMSAllocText(FunctionDecl *FD)
Only called on function definitions; if there is a #pragma alloc_text that decides which code section...
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
IdentifierResolver IdResolver
bool isSimpleTypeSpecifier(tok::TokenKind Kind) const
Determine whether the token kind starts a simple-type-specifier.
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, UnresolvedLookupExpr *AsULE=nullptr)
Builds an expression which might be an implicit member expression.
bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const
IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.
void DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName=false)
void DiagnoseSizeOfParametersAndReturnValue(ArrayRef< ParmVarDecl * > Parameters, QualType ReturnTy, NamedDecl *D)
Diagnose whether the size of parameters or return value of a function or obj-c method definition is p...
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceModel SemanticSpelling)
TemplateNameKindForDiagnostics
Describes the detailed kind of a template name. Used in diagnostics.
void checkCUDATargetOverload(FunctionDecl *NewFD, const LookupResult &Previous)
Check whether NewFD is a valid overload for CUDA.
void warnOnReservedIdentifier(const NamedDecl *D)
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
void ActOnObjCTemporaryExitContainerContext(ObjCContainerDecl *ObjCCtx)
Invoked when we must temporarily exit the objective-c container scope for parsing/looking-up C constr...
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD=nullptr)
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet)
Act on the result of classifying a name as an overload set.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include'd file otherwise it returns an invalid location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
StringRef getString() const
Represents the declaration of a struct/union/class/enum.
static TagDecl * castFromDeclContext(const DeclContext *DC)
bool isBeingDefined() const
Return true if this decl is currently being defined.
TagDecl * getDefinition() const
Returns the TagDecl that actually defines this struct/union/class/enum.
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
void startDefinition()
Starts the definition of this tag declaration.
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
TagKind getTagKind() const
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Exposes information about the current target.
virtual bool validateCpuIs(StringRef Name) const
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
virtual bool allowDebugInfoForExternalRef() const
Whether target allows debuginfo types for decl only variables/functions.
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
bool isTLSSupported() const
Whether the target supports thread-local storage.
unsigned getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
virtual bool validateCpuSupports(StringRef Name) const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool isValidFeatureName(StringRef Feature) const
Determine whether this TargetInfo supports the given feature.
unsigned getCharWidth() const
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
bool supportsMultiVersioning() const
Identify whether this target supports multiversioning of functions, which requires support for cpu_su...
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
virtual bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getRAngleLoc() const
SourceLocation getTemplateLoc() const
Represents a type template specialization; the template must be a class template, a type alias templa...
static bool anyInstantiationDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args)
Token - This structure provides full information about a lexed token.
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
bool isNot(tok::TokenKind K) const
Represents a declaration of a type.
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
Base wrapper for a particular "section" of type source info.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getEndLoc() const
Get the end source location.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
void setNameLoc(SourceLocation Loc)
static StringRef getTagTypeKindName(TagTypeKind Kind)
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isStructureType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isDependentSizedArrayType() const
bool isBlockPointerType() const
bool isBooleanType() const
bool isFunctionReferenceType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool isFunctionPointerType() const
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
bool isReferenceType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
const RecordType * getAsStructureType() const
bool containsErrors() const
Whether this type is an error type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCIdType() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isMemberFunctionPointerType() const
bool isFloatingType() const
bool isAnyPointerType() const
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading 'auto' corresponding to a trailing return type...
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
bool isFunctionNoProtoType() const
bool isReserveIDT() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Base class for declarations which introduce a typedef-name.
TypeSourceInfo * getTypeSourceInfo() const
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
QualType getUnderlyingType() const
void setTypeSourceInfo(TypeSourceInfo *newType)
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
TypedefNameDecl * getDecl() const
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
SmallVectorImpl< NamedDecl * >::const_iterator const_decl_iterator
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
static bool isIncrementDecrementOp(Opcode Op)
Represents a C++ unqualified-id that has been parsed.
UnqualifiedIdKind Kind
Describes the kind of unqualified-id parsed.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
The iterator over UnresolvedSets.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setCXXForRangeDecl(bool FRD)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
TLSKind getTLSKind() const
void setInitStyle(InitializationStyle Style)
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
@ ListInit
Direct list-initialization (C++11)
@ CallInit
Call-style initialization (C++98)
void setStorageClass(StorageClass SC)
void setPreviousDeclInSameBlockScope(bool Same)
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setInlineSpecified()
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
void setTSCSpec(ThreadStorageClassSpecifier TSC)
bool checkForConstantInitialization(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the initializer of this variable to determine whether it's a constant initializer.
bool isInline() const
Whether this variable is (C++1z) inline.
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
void setConstexpr(bool IC)
@ TLS_Static
TLS with a known-constant initializer.
@ TLS_Dynamic
TLS with a dynamic initializer.
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
@ TentativeDefinition
This declaration is a tentative definition.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
void setDescribedVarTemplate(VarTemplateDecl *Template)
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void setImplicitlyInline()
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
void demoteThisDefinitionToDeclaration()
This is a definition which should be demoted to a declaration.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
Captures information about a #pragma weak directive.
void disableCheckFallThrough()
Policy getDefaultPolicy()
bool isVariableCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
VarDecl * getVariable() const
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
bool UsesFPIntrin
Whether this function uses constrained floating point intrinsics.
void addByrefBlockVar(VarDecl *VD)
bool NeedsScopeChecking() const
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc,...
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
llvm::SmallVector< ShadowedOuterDecl, 4 > ShadowingDecls
CXXRecordDecl * Lambda
The class that describes the lambda.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
bool Mutable
Whether this is a mutable lambda.
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Attr > attr
const AstTypeMatcher< RecordType > recordType
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
bool randomizeStructureLayout(const ASTContext &Context, RecordDecl *RD, llvm::SmallVectorImpl< Decl * > &FinalOrdering)
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an '@'.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
TypeSpecifierType
Specifies the kind of type.
bool isa(CodeGen::Address addr)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ GVA_AvailableExternally
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
ConstexprSpecKind
Define the kind of constexpr specifier.
InClassInitStyle
In-class initialization styles for non-static data members.
@ ICIS_NoInit
No in-class initializer.
OverloadCandidateDisplayKind
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ LCK_ByRef
Capturing by reference.
@ LCK_StarThis
Capturing the *this object by copy.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
SmallVector< Attr *, 4 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D)
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
StorageClass
Storage classes.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
@ TSCS_thread_local
C++11 thread_local.
@ TSCS__Thread_local
C11 _Thread_local.
@ TSCS___thread
GNU __thread.
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
MutableArrayRef< Expr * > MultiExprArg
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ ModuleLinkage
Module linkage, which indicates that the entity can be referred to from other translation units withi...
@ C
Languages that the frontend can parse and compile.
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Parameter
The parameter type of a method or function.
@ Result
The result type of a method or function.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
TagTypeKind
The kind of a tag type.
@ TTK_Class
The "class" keyword.
@ TTK_Enum
The "enum" keyword.
@ TTK_Struct
The "struct" keyword.
@ TTK_Union
The "union" keyword.
@ TTK_Interface
The "__interface" keyword.
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
bool isDiscardableGVALinkage(GVALinkage L)
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ TU_Complete
The translation unit is a complete translation unit.
int hasAttribute(AttributeCommonInfo::Syntax Syntax, const IdentifierInfo *Scope, const IdentifierInfo *Attr, const TargetInfo &Target, const LangOptions &LangOpts)
Return the version number associated with the attribute if we recognize and implement the attribute s...
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
U cast(CodeGen::Address addr)
@ None
The alignment was not explicit in code.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
@ ETK_Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ ETK_None
No keyword precedes the qualified type name.
@ EST_None
no exception specification
@ EST_BasicNoexcept
noexcept
Visibility
Describes the different kinds of visibility that a declaration may have.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setCXXOperatorNameRange(SourceRange R)
setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword).
SourceRange getCXXOperatorNameRange() const
getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword).
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
SourceLocation getConstQualifierLoc() const
Retrieve the location of the 'const' qualifier.
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
ArrayRef< NamedDecl * > getDeclsInPrototype() const
Get the non-parameter decls defined within this function prototype.
SourceLocation getRParenLoc() const
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
One instance of this struct is used for each type in a declarator that is parsed.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
enum clang::DeclaratorChunk::@209 Kind
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
MemberPointerTypeInfo Mem
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
EvalResult is a struct with detailed info about an evaluated expression.
Extra information about a function prototype.
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
Contains information gathered from parsing the contents of TargetAttr.
std::vector< std::string > Features
Describes how types, statements, expressions, and declarations should be printed.
SourceLocation PragmaLocation
Information about a template-id annotation token.
unsigned NumArgs
NumArgs - The number of template arguments.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.